מדריך למשתמש לתכנות Nanotic NanoLib C++

לפני שתתחיל:
- ודא שהמערכת שלך עומדת בדרישות החומרה המפורטות במדריך. הקהל המיועד למוצר זה כולל מפתחים המעוניינים ליצור תוכנת שליטה עבור בקרי Nanotec.

תחילת העבודה:
- כדי להתחיל להשתמש ב-NanoLib, בצע את השלבים הבאים:
- התחל בייבוא NanoLib לפרויקט שלך.
- הגדר את הגדרות הפרויקט שלך לפי הצורך.
- בנה את הפרויקט שלך כדי לשלב פונקציונליות של NanoLib.
יצירת פרויקטים:
- אתה יכול ליצור פרויקטים עבור סביבות Windows ו- Linux כאחד. עקוב אחר ההוראות הספציפיות המופיעות במדריך עבור כל פלטפורמה.
התייחסות לשיעורים / פונקציות:
- עיין במדריך למשתמש לקבלת מדריך מפורט על השיעורים והפונקציות הזמינות ב-NanoLib לתכנות תוכנת בקרה.

שאלות נפוצות

ש: מה המטרה של NanoLib?
- A: NanoLib היא ספרייה לתכנות תוכנת בקרה עבור בקרי Nanotec, המספקת פונקציות חיוניות ויכולות תקשורת.
ש: איך אני יכול להתחיל עם NanoLib?
- A: התחל בייבוא NanoLib לפרויקט שלך, הגדרת הגדרות הפרויקט ובניית הפרויקט שלך כך שישתמש בתכונות NanoLib.

View Fullscreen

מדריך למשתמש NanoLib
C++

תקף עם גרסה 1.3.0 של המוצר

גירסת מדריך למשתמש: 1.4.2

תיעוד מטרה ומוסכמות

מסמך זה מתאר את ההגדרה והשימוש בספריית NanoLib ומכיל הפניה לכל המחלקות והפונקציות לתכנות תוכנת הבקרה שלך עבור בקרי Nanotec. אנו משתמשים בפונטים הבאים:
טקסט עם קו תחתון מסמן הפניה צולבת או היפר קישור.
Exampדף 1: להוראות מדויקות על ה-NanoLibAccessor, ראה הגדרה. לְשֶׁעָבַרampחלק 2: התקן את מנהל ההתקן של Ixxat וחבר את מתאם ה-CAN ל-USB. טקסט נטוי פירושו: זהו אובייקט בעל שם, נתיב תפריט / פריט, כרטיסייה / file שם או (במידת הצורך) ביטוי בשפה זרה.
Example 1: בחר File > חדש > מסמך ריק. פתח את הכרטיסייה כלי ובחר תגובה. לְשֶׁעָבַרample 2: מסמך זה מפריד בין משתמשים (= Nutzer; usuario; utente; utilisateur; utente וכו') בין:
– משתמש צד שלישי (= Drittnitzer; tercero usuario; terceiro utente; tiers utilisateur; terzo utente וכו'). – משתמש קצה (= Endnutzer; usuario final; utente final; utilisateur final; utente final וכו').
שליח מסמן בלוקי קוד או פקודות תכנות. לְשֶׁעָבַרampחלק 1: דרך Bash, קרא sudo make install כדי להעתיק אובייקטים משותפים; ואז תתקשר ל-ldconfig. לְשֶׁעָבַרampחלק 2: השתמש בפונקציית NanoLibAccessor הבאה כדי לשנות את רמת הרישום ב- NanoLib:
// ***** וריאנט C++ *****
void setLoggingLevel(רמת LogLevel);
טקסט מודגש מדגיש מילים בודדות בעלות חשיבות קריטית. לחלופין, סימני קריאה בסוגריים מדגישים את החשיבות הקריטית(!).
Example 1: הגן על עצמך, על אחרים ועל הציוד שלך. עקבו אחר הערות הבטיחות הכלליות שלנו החלות באופן כללי על כל מוצרי Nanotec.
Example 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 תומך בכל מוצרי Nanotec עם CANopen, Modbus RTU (גם USB ביציאת COM וירטואלית), Modbus TCP, EtherCat ו-Profinet. עבור NanoLibs ישנים יותר: ראה יומן שינויים בהחתמה. על אחריותך בלבד: שימוש במערכת מדור קודם. הערה: עקוב אחר הוראות OEM חוקיות כדי להגדיר את זמן האחזור נמוך ככל האפשר אם אתה נתקל בבעיות בעת שימוש במתאם USB מבוסס FTDI.

דרישות (מערכת 64 סיביות חובה)
Windows 10 או 11 עם Visual Studio 2019 גרסה 16.8 ואילך ו-Windows SDK 10.0.20348.0 (גרסה 2104) ואילך
C++ ניתנים להפצה מחדש 2017 ומעלה CANopen: מנהל התקן בסיסי של Ixxat VCI או PCAN (אופציונלי) מודול EtherCat / Profinet DCP: Npcap או WinPcap מודול RESTful: Npcap, WinPcap, או הרשאת מנהל ל
לתקשר עם מאגרי אתחול Ethernet
לינוקס עם אובונטו 20.04 LTS עד 24 (כולם x64 ו-arm64)
כותרות ליבה וחבילת libpopt-dev Profinet DCP: CAP_NET_ADMIN ו-CAP_NET_RAW abili-
קשרים CANopen: מנהל התקן Ixxat ECI או מתאם PCAN-USB Peak EtherCat: CAP_NET_ADMIN, CAP_NET_RAW ו
יכולות CAP_SYS_NICE RESTful: יכולת CAP_NET_ADMIN לתקשר עם Eth-
מטעני אתחול של ernet (מומלצים גם: CAP_NET_RAW)

שפה, מתאמי fieldbus, כבלים
C++ GCC 7 ומעלה (Linux)
EtherCAT: כבל Ethernet VCP / רכזת USB: כעת אחסון USB USB אחיד: כבל USB REST: כבל Ethernet CANopen: Ixxat USB-to-CAN V2; לא-
notec ZK-USB-CAN-1, מתאם PCANUSB שיא ללא תמיכה ב-Ixxat עבור אובונטו ב-arm64
Modbus RTU: Nanotec ZK-USB-RS485-1 או מתאם שווה ערך; כבל USB ביציאת תקשורת וירטואלית (VCP)
Modbus TCP: כבל Ethernet לפי גיליון הנתונים של המוצר

2.2 שימוש וקהל יעד
NanoLib היא ספריית תוכניות ורכיב תוכנה לתפעול ותקשורת עם בקרי Nanotec במגוון רחב של יישומים תעשייתיים ולמתכנתים מיומנים בלבד.
עקב חומרה (PC) ומערכת הפעלה לא מסוגלים בזמן אמת, NanoLib אינו מיועד לשימוש ביישומים הזקוקים לתנועה רב צירית סינכרונית או שהם בדרך כלל רגישים לזמן.
בשום מקרה אסור לשלב את NanoLib כרכיב בטיחות במוצר או במערכת. במשלוח למשתמשי הקצה, עליך להוסיף הודעות אזהרה מתאימות והוראות לשימוש בטוח ותפעול בטוח לכל מוצר עם רכיב המיוצר על ידי Nanotec. עליך להעביר את כל הודעות האזהרה שהונפקו על ידי Nanotec ישירות למשתמש הקצה.
2.3 היקף משלוח ואחריות
NanoLib מגיע כתיקיית *.zip מההורדה שלנו webאתר עבור EMEA / APAC או אמריקה. אחסן ופתח את ההורדה שלך לפני ההגדרה. חבילת NanoLib מכילה:

גרסה: doc 1.4.2 / NanoLib 1.3.0

2 לפני שתתחיל

כותרות ממשק כקוד מקור (API)

פונקציות ליבה כספריות בפורמט בינארי: ננו-

ספריות המקלות על תקשורת: nanolibm_ lib.dll

[yourfieldbus].dll וכו'.

Exampלפרויקט: דוגמהample.sln (Visual Studio

פרויקט) ואקסample.cpp (ראשי file)

לגבי היקף האחריות, נא לעקוב אחר א) התנאים וההגבלות שלנו עבור EMEA / APAC או אמריקה וב) כל תנאי הרישיון. הערה: Nanotec אינה אחראית לאיכות לקויה או לא ראויה, טיפול, התקנה, תפעול, שימוש ותחזוקה של ציוד של צד שלישי! למען הבטיחות הראויה, פעל תמיד לפי הוראות OEM תקפות.

גרסה: doc 1.4.2 / NanoLib 1.3.0

ארכיטקטורת NanoLib

מבנה התוכנה המודולרי של NanoLib מאפשר לך לארגן פונקציות של בקר מנוע/אוטובוס שדה הניתנים להתאמה אישית באופן חופשי סביב ליבה שנבנתה מראש. NanoLib מכיל את המודולים הבאים:

ממשק משתמש (API)

ליבת NanoLib

שיעורי ממשק ועזר אילו ספריות אילו

ספריות תקשורת ספריות ספציפיות ל-Fieldbus אשר

לגשת לך אל הבקר שלך ליישם את פונקציונליות ה-API לעשות ממשק בין NanoLib

OD (מילון אובייקט)

אינטראקציה עם ספריות אוטובוסים.

חומרת ליבה ואפיק.

בסיס על פונקציית הליבה של NanoLib-

רציונליות.

3.1 ממשק משתמש

ממשק המשתמש מורכב ממשק כותרת fileאתה יכול להשתמש כדי לגשת לפרמטרים של הבקר. מחלקות ממשק המשתמש כפי שמתוארות בהפניה לשיעורים / פונקציות מאפשרות לך:
חבר גם לחומרה (מתאם שדה-בוס) וגם להתקן הבקר. גש ל-OD של המכשיר, כדי לקרוא/לכתוב את פרמטרי הבקר.

3.2 ליבת NanoLib

הליבה של NanoLib מגיעה עם ספריית הייבוא nanolib.lib. הוא מיישם את פונקציונליות ממשק המשתמש ואחראי על:
טעינה וניהול של ספריות התקשורת. מתן פונקציונליות ממשק המשתמש ב- NanoLibAccessor. נקודת הכניסה לתקשורת זו מתארת-
קנס קבוצה של פעולות שאתה יכול לבצע על הליבה של NanoLib וספריות התקשורת.

3.3 ספריות תקשורת

בנוסף ל-nanotec.services.nanolib.dll (שימושי עבור סטודיו Plug & Drive האופציונלי), 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, התקן את MS Visual Studio עם הרחבות C++. כדי להתקין make ו-gcc של Linux Bash, התקשר ל-sudo apt install build-essentials. לאחר מכן, הפעל את יכולות CAP_NET_ADMIN, CAP_NET_RAW ו-CAP_SYS_NICE עבור היישום המשתמש ב-NanoLib: 1. התקשר ל-sudo setcap 'cap_net_admin,cap_net_raw,cap_sys_nice+eip'
שם>. 2. רק לאחר מכן, התקן את מנהלי ההתקן של המתאם שלך.
4.2 התקן את מנהל ההתקן של מתאם Ixxat עבור Windows
רק לאחר התקנת מנהל ההתקן, תוכל להשתמש במתאם USB-to-CAN V2 של Ixxat. קרא את מדריך המוצר של כונני ה-USB, כדי ללמוד אם / כיצד להפעיל את התיאום הוירטואלי (VCP). 1. הורד והתקן את מנהל ההתקן VCI 4 של Ixxat עבור Windows מ www.ixxat.com. 2. חבר את המתאם הקומפקטי USB-to-CAN V2 של Ixxat למחשב באמצעות USB. 3. לפי מנהל ההתקנים: בדוק אם גם מנהל ההתקן וגם המתאם מותקנים/ מזוהים כהלכה.
4.3 התקן את מנהל ההתקן של מתאם Peak עבור Windows
רק לאחר התקנת מנהל ההתקן, תוכל להשתמש במתאם PCAN-USB של Peak. קרא את מדריך המוצר של כונני ה-USB, כדי ללמוד אם / כיצד להפעיל את התיאום הוירטואלי (VCP). 1. הורד והתקן את הגדרת מנהל ההתקן של Windows (=חבילת התקנה עם מנהלי התקנים, כלים ו
ממשקי API) מ http://www.peak-system.com. 2. חבר את מתאם PCAN-USB של Peak למחשב באמצעות USB. 3. לפי מנהל ההתקנים: בדוק אם גם מנהל ההתקן וגם המתאם מותקנים/ מזוהים כהלכה.
4.4 התקן את מנהל ההתקן של מתאם Ixxat עבור לינוקס
רק לאחר התקנת מנהל ההתקן, תוכל להשתמש במתאם USB-to-CAN V2 של Ixxat. הערה: מתאמים נתמכים אחרים זקוקים להרשאות שלך על ידי 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 buildessential
2. הורד את מנהל ההתקן של ECI-for-Linux מ-www.ixxat.com. פתח אותו באמצעות:
פתח את eci_driver_linux_amd64.zip
3. התקן את מנהל ההתקן באמצעות:
cd /EciLinux_amd/src/KernelModule sudo make install-usb
4. בדוק אם התקנת מנהל התקן מוצלחת על ידי קומפילציה והפעלה של יישום ההדגמה:
cd /EciLinux_amd/src/EciDemos/ sudo make cd /EciLinux_amd/bin/release/ ./LinuxEciDemo

גרסה: doc 1.4.2 / NanoLib 1.3.0

4 תחילת העבודה
4.5 התקן את מנהל ההתקן של מתאם Peak עבור לינוקס
רק לאחר התקנת מנהל ההתקן, תוכל להשתמש במתאם PCAN-USB של Peak. הערה: מתאמים נתמכים אחרים זקוקים להרשאות שלך על ידי 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.
א) בדוק את מודול הליבה:
lsmod | grep pcan b) … והספרייה המשותפת:
ls -l /usr/lib/libpcan*
הערה: אם מתרחשות בעיות USB3, השתמש ביציאת USB2.
4.6 חבר את החומרה שלך
כדי להיות מסוגל להפעיל פרויקט NanoLib, חבר בקר Nanotec תואם למחשב באמצעות המתאם שלך. 1. באמצעות כבל מתאים, חבר את המתאם לבקר. 2. חבר את המתאם למחשב לפי גיליון הנתונים של המתאם. 3. הפעל את הבקר באמצעות ספק כוח מתאים. 4. במידת הצורך, שנה את הגדרות התקשורת של בקר Nanotec בהתאם להוראות במדריך המוצר שלו.
4.7 טען NanoLib
להתחלה ראשונה עם יסודות מהירים וקלים, אתה יכול (אך לא חייב) להשתמש באקס שלנוampלפרויקט. 1. בהתאם לאזור שלך: הורד את NanoLib מאתנו webאתר עבור EMEA / APAC או אמריקה. 2. פתח את החבילה files / תיקיות ובכן בחר אפשרות אחת: ליסודות מהירים וקלים: ראה התחלת ה-exampלפרויקט. להתאמה אישית מתקדמת ב-Windows: ראה יצירת פרויקט Windows משלך. להתאמה אישית מתקדמת בלינוקס: ראה יצירת פרויקט לינוקס משלך.

גרסה: doc 1.4.2 / NanoLib 1.3.0

מתחיל את האקסampלפרויקט

עם NanoLib טעון כהלכה, האקסample project מראה לך את השימוש ב-NanoLib עם בקר Nanotec. הערה: עבור כל שלב, הערות בדוגמה שסופקהampהקוד מסביר את הפונקציות בהן נעשה שימוש. האקסampהפרוייקט le מורכב מ: ה- `*_functions_example.*' files, המכילים את ההטמעות עבור ממשק NanoLib פונקציות ה- `*_callback_example.*' files, המכילים יישומים עבור ההתקשרויות השונות (סריקה, נתונים ו
רישום) ה- `menu_*.*' file, המכיל את הלוגיקה של התפריט וקוד ה-Example.* file, שהיא התוכנית הראשית, יוצרת את התפריט ואתחול כל הפרמטרים בשימוש ה-Sampler_example.* file, המכיל את האקסample יישום עבור sampשימוש בלר. אתה יכול למצוא עוד אקסamples, עם כמה פקודות תנועה עבור מצבי פעולה שונים, ב- Knowledge Base בכתובת nanotec.com. כולם ניתנים לשימוש ב-Windows או Linux.
ב-Windows עם Visual Studio 1. פתח את ה-Example.sln file. 2. פתח את האקסample.cpp. 3. הידור והפעל את האקסampאת הקוד.
בלינוקס דרך Bash 1. פתח את המקור file, נווט אל התיקיה עם תוכן שנפרם. העיקרית file עבור האקסיתample הוא
example.cpp. 2. ב-bash, התקשר:
א. "sudo make install" כדי להעתיק את האובייקטים המשותפים ולקרוא ל-ldconfig. ב. "עשה הכל" כדי לבנות את קובץ ההפעלה של הבדיקה. 3. תיקיית bin מכילה דוגמה להפעלהample file. על ידי bash: עבור אל תיקיית הפלט והקלד ./example. אם לא מתרחשת שגיאה, האובייקטים המשותפים שלך מותקנים כעת כהלכה, והספרייה שלך מוכנה לשימוש. אם השגיאה קורא ./example: שגיאה בעת טעינת ספריות משותפות: libnanolib.so: לא ניתן לפתוח אובייקט משותף file: אין כזה file או ספריה, התקנת האובייקטים המשותפים נכשלה. במקרה זה, בצע את השלבים הבאים. 4. צור תיקיה חדשה בתוך /usr/local/lib (דרושות זכויות מנהל). לתוך ה-bash, כך הקלד:
sudo mkdir /usr/local/lib/nanotec
5. העתק את כל האובייקטים המשותפים מה-zip 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 התחלת האקסampלפרויקט
5. בדוק אחת או יותר מפונקציות הספרייה: קריאה/כתיבה מ/אל מילון האובייקטים של הבקר, עדכן את הקושחה, העלה והרצה של תוכנית NanoJ, הפעל את המנוע וכוונו אותו, תגדיר והשתמש ברישום/יםampלר.
6. סגור את החיבור, תחילה למכשיר, ולאחר מכן למתאם.

גרסה: doc 1.4.2 / NanoLib 1.3.0

יצירת פרויקט Windows משלך

צור, הידור והפעל פרויקט Windows משלך כדי להשתמש ב-NanoLib.
6.1 ייבוא NanoLib
ייבא את הכותרת של NanoLib files וספריות באמצעות MS Visual Studio.
1. פתח את Visual Studio. 2. דרך צור פרויקט חדש > אפליקציית מסוף C++ > הבא: בחר סוג פרויקט. 3. תן שם לפרויקט שלך (כאן: NanolibTest) כדי ליצור תיקיית פרויקט בסייר הפתרונות. 4. בחר סיום. 5. פתח את החלונות file סייר ונווט אל תיקיית הפרויקט החדשה שנוצרה. 6. צור שתי תיקיות חדשות, inc ו-lib. 7. פתח את תיקיית החבילה NanoLib. 8. משם: העתק את הכותרת files מתיקיית include לתוך תיקיית הפרויקט שלך inc וכל lib ו-.dll
files לתיקיית הפרויקט החדשה שלך lib. 9. בדוק את תיקיית הפרויקט שלך עבור מבנה מתאים, למשלampעל:

תיקיית ect למבנה המתאים:
. NanolibTest inc accessor_factory.hpp bus_hardware_id.hpp … od_index.hpp result_od_entry.hpp lib nanolibm_canopen.dll nanolib.dll … nanolib.lib NanolibTest.cpp NanolibTest.vcxproj NanolibTest.vcxproj.filters NanolibTest.vcxproj. NanolibTest.sln
6.2 הגדר את הפרויקט שלך
השתמש בסייר הפתרונות ב-MS Visual Studio כדי להגדיר פרויקטים של NanoLib. הערה: לפעולה נכונה של NanoLib, בחר את תצורת השחרור (לא באגים!) בהגדרות פרוייקט Visual C++; לאחר מכן בנה וקשר את הפרויקט עם זמני ריצה של VC של ניתנים להפצה מחדש של C++ [2022].
1. בסייר הפתרונות: עבור אל תיקיית הפרויקט שלך (כאן: NanolibTest). 2. לחץ יחד על התיקיה כדי לפתוח את תפריט ההקשר. 3. בחר מאפיינים. 4. הפעל את כל התצורות ואת כל הפלטפורמות. 5. בחר C/C++ ועבור ל-Additional Include Directory. 6. הכנס: $(ProjectDir)Nanolib/includes;%(AdditionalIncludeDirectories) 7. בחר Linker ועבור אל ספריות נוספות של ספרייה. 8. הכנס: $(ProjectDir)Nanolib;%(AdditionalLibraryDirectories) 9. הרחב את הקישור ובחר בקלט. 10. עבור אל תלות נוספת והוסף: nanolib.lib;%(AdditionalDependencies) 11. אשר באמצעות OK.

גרסה: doc 1.4.2 / NanoLib 1.3.0

6 יצירת פרויקט Windows משלך
12. עבור אל Configuration > C++ > Language > Language Standard > ISO C++17 Standard והגדר את תקן השפה ל-C++17 (/std:c++17).
6.3 בנה את הפרויקט שלך
בנה את פרויקט NanoLib שלך ב-MS Visual Studio. 1. פתח את ה-*.cpp הראשי file (כאן: nanolib_example.cpp) וערוך את הקוד, אם צריך. 2. בחר Build > Configuration Manager. 3. שנה את פלטפורמות הפתרונות הפעילים ל-x64. 4. אשר באמצעות סגור. 5. בחר בנייה > בניית פתרון. 6. אין שגיאה? בדוק אם פלט הקומפילציה שלך מדווח כראוי:
1>—— התחיל נקי: פרוייקט: NanolibTest, תצורה: Debug x64 —–=========== נקי: 1 הצליח, 0 נכשל, 0 דילג ==========

גרסה: doc 1.4.2 / NanoLib 1.3.0

7 יצירת פרויקט לינוקס משלך
7 יצירת פרויקט לינוקס משלך
צור, הידור והפעל פרויקט לינוקס משלך כדי להשתמש ב-NanoLib. 1. בערכת ההתקנה הנפתחת של NanoLib: פתח /nanotec_nanolib. 2. מצא את כל האובייקטים המשותפים ב-tar.gz file. 3. בחר אפשרות אחת: התקן כל lib או עם Makefile או ביד.
7.1 התקן את האובייקטים המשותפים עם Makefile
השתמש ב-Makefile עם Linux Bash כדי להתקין אוטומטית את כל ברירת המחדל של *.so fileס. 1. Via Bash: עבור לתיקיה המכילה את ה-makefile. 2. העתק את האובייקטים המשותפים באמצעות:
sudo make install 3. אשר באמצעות:
ldconfig
7.2 התקן את האובייקטים המשותפים ביד
השתמש ב-Bash כדי להתקין את כל *.so files של NanoLib באופן ידני. 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. Via Bash: צור תיקיית פרויקט חדשה (כאן: NanoLibTest) באמצעות:
mkdir NanoLibTest cd NanoLibTest
2. העתק את הכותרת files לתיקיית include (כאן: inc) דרך: mkdir inc cp / FILE IS>/nanotec_nanolib/inc/*.hpp inc
3. צור ראשי file (NanoLibTest.cpp) באמצעות: #include "accessor_factory.hpp" #include

גרסה: doc 1.4.2 / NanoLib 1.3.0

7 יצירת פרויקט לינוקס משלך
int main(){ nlc::NanoLibAccessor *accessor = getNanoLibAccessor();
nlc::ResultBusHwIds result = accessor->listAvailableBusHardware();
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 result.hpp NanoLibTest.cpp
7.4 הידור ובדוק את הפרויקט שלך
הכן את Linux NanoLib שלך לשימוש באמצעות Bash.
1. Via Bash: הידור הראשי file בְּאֶמצָעוּת:
g++ -Wall -Wextra -pedantic -I./inc -c NanoLibTest.cpp -o NanoLibTest
2. קשר את קובץ ההפעלה יחד באמצעות:
g++ -Wall -Wextra -pedantic -I./inc -o test NanoLibTest.o L/usr/local/lib/nanotec -lnanolib -ldl
3. הפעל את תוכנית הבדיקה באמצעות:
./מִבְחָן
4. בדוק אם Bash שלך מדווח כהלכה:
הַצלָחָה

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

מצא כאן רשימה של מחלקות ממשק המשתמש של NanoLib ופונקציות החברים שלהן. התיאור הטיפוסי של פונקציה כולל מבוא קצר, הגדרת הפונקציה ורשימת פרמטרים / החזרה:

ExampleFunction () אומר לך בקצרה מה הפונקציה עושה.
ריק וירטואלי 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

מספק מערך מזהה אוטובוס שטח.

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 מחזירה true
שֶׁקֶר

מציין כל אוטובוס שדה לפתיחה. החומרה פתוחה. החומרה סגורה.

getProtocolSpecificAccessor () השתמש בפונקציה זו כדי לקבל את אובייקט הגישה הספציפי לפרוטוקול.
virtual ResultVoid nlc::NanoLibAccessor::getProtocolSpecificAccessor (BusHardwareId const & busHwId)

פרמטרים busHwId מחזירה ResultVoid

מציין את אוטובוס השדה שאליו יש להשיג את העזר. מאשר שפונקציית בטל פעלה.

getProfinetDCP () השתמש בפונקציה זו כדי להחזיר הפניה לממשק Profinet DCP.
ProfinetDCP וירטואלי וgetProfinetDCP ()

מחזירה ProfinetDCP

getSamplerInterface () השתמש בפונקציה זו כדי לקבל הפניה ל-sampממשק ler.
וירטואלי SamplerInterface & getSamplerInterface ()

מחזיר את סampממשק ler

מתייחס לס'ampמחלקת ממשק ler.

setBusState () השתמש בפונקציה זו כדי להגדיר את המצב הספציפי לאוטובוס.
virtual ResultVoid nlc::NanoLibAccessor::setBusState (const BusHardwareId & busHwId, const std::string & state)

פרמטרים busHwId state
מחזירה את ResultVoid

מציין את אוטובוס השדה שייפתח. מקצה מצב ספציפי לאוטובוס כערך מחרוזת. מאשר שפונקציית בטל פעלה.

scanDevices () השתמש בפונקציה זו כדי לסרוק אחר התקנים ברשת.
virtual ResultDeviceIds nlc::NanoLibAccessor::scanDevices (const BusHardwareId & busHwId, NlcScanBusCallback* callback)

פרמטרים busHwId callback
מחזירה ResultDeviceIds IOError

מציין את אוטובוס השדה לסריקה. מעקב התקדמות NlcScanBusCallback. מספק מערך מזהה מכשיר. מודיע שלא נמצא מכשיר.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

addDevice ()
השתמש בפונקציה זו כדי להוסיף התקן אוטובוס המתואר על ידי deviceId לרשימת ההתקנים הפנימית של NanoLib, ולהחזיר את deviceHandle עבורו.
virtual ResultDeviceHandle nlc::NanoLibAccessor::addDevice (DeviceId const & deviceId)

פרמטרים deviceId מחזיר את ResultDeviceHandle

מציין את המכשיר שיש להוסיף לרשימה. מספק ידית למכשיר.

connectDevice () השתמש בפונקציה זו כדי לחבר התקן באמצעות deviceHandle.
virtual ResultVoid nlc::NanoLibAccessor::connectDevice (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultVoid
שגיאה

מציין לאיזה מכשיר אוטובוס NanoLib מתחבר. מאשר שפונקציית בטל פעלה. מודיע שלא נמצא מכשיר.

getDeviceName () השתמש בפונקציה זו כדי לקבל שם מכשיר על ידי deviceHandle.
virtual ResultString nlc::NanoLibAccessor::getDeviceName (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultString

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את השם. מספק שמות מכשירים כמחרוזת.

getDeviceProductCode () השתמש בפונקציה זו כדי לקבל קוד מוצר של מכשיר על ידי deviceHandle.
virtual ResultInt nlc::NanoLibAccessor::getDeviceProductCode (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultInt

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את קוד המוצר. מספק קודי מוצר כמספר שלם.

getDeviceVendorId () השתמש בפונקציה זו כדי לקבל את מזהה ספק ההתקן על ידי deviceHandle.
virtual ResultInt nlc::NanoLibAccessor::getDeviceVendorId (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultInt
משאב לא זמין

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את מזהה הספק. מספק מזהי ספק כמספר שלם. מודיע שלא נמצא נתונים.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

getDeviceId () השתמש בפונקציה זו כדי לקבל מזהה של מכשיר ספציפי מהרשימה הפנימית של NanoLib.
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceId (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultDeviceId

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את מזהה המכשיר. מספק מזהה מכשיר.

getDeviceIds () השתמש בפונקציה זו כדי לקבל מזהה של כל המכשירים מהרשימה הפנימית של NanoLib.
virtual ResultDeviceIds nlc::NanoLibAccessor::getDeviceIds ()

מחזירה ResultDeviceIds

מספק רשימת מזהי מכשיר.

getDeviceUid () השתמש בפונקציה זו כדי לקבל מזהה ייחודי של מכשיר (96 סיביות / 12 בתים) על ידי deviceHandle.
virtual ResultArrayByte nlc::NanoLibAccessor::getDeviceUid (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultArrayByte
משאב לא זמין

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את המזהה הייחודי. מספק מזהים ייחודיים כמערך בתים. מודיע שלא נמצא נתונים.

getDeviceSerialNumber () השתמש בפונקציה זו כדי לקבל את המספר הסידורי של התקן באמצעות deviceHandle.
virtual ResultString NanolibAccessor::getDeviceSerialNumber (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultString
משאב לא זמין

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את המספר הסידורי. מספק מספרים סידוריים כמחרוזת. מודיע שלא נמצא נתונים.

getDeviceHardwareGroup () השתמש בפונקציה זו כדי לקבל קבוצת חומרה של התקן אפיק לפי deviceHandle.
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceHardwareGroup (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultInt

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את קבוצת החומרה.
מספק קבוצות חומרה כמספר שלם.

getDeviceHardwareVersion () השתמש בפונקציה זו כדי לקבל את גרסת החומרה של התקן אוטובוס על ידי deviceHandle.
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceHardwareVersion (DeviceHandle const deviceHandle)

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

פרמטרים deviceHandle

מחזיר

ResultString ResourceUnaavailable

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את גרסת החומרה עבורו. מספק שמות מכשירים כמחרוזת. מודיע שלא נמצא נתונים.

getDeviceFirmwareBuildId () השתמש בפונקציה זו כדי לקבל מזהה בניית קושחה של התקן אפיק על ידי deviceHandle.
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceFirmwareBuildId (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultString

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את מזהה בניית הקושחה.
מספק שמות מכשירים כמחרוזת.

getDeviceBootloaderVersion () השתמש בפונקציה זו כדי לקבל את גרסת טוען האתחול של התקן אוטובוס על ידי deviceHandle.
virtual ResultInt nlc::NanoLibAccessor::getDeviceBootloaderVersion (DeviceHandle const deviceHandle)

פרמטרים deviceHandle

מחזיר

ResultInt ResourceUnaavailable

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את גרסת טוען האתחול. מספק גרסאות מאתחול כמספר שלם. מודיע שלא נמצא נתונים.

getDeviceBootloaderBuildId () השתמש בפונקציה זו כדי לקבל מזהה בנייה של מטעין האתחול של התקן אוטובוס על ידי deviceHandle.
virtual ResultDeviceId nlc::NanoLibAccessor:: (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultString

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את מזהה ה-builderloader האתחול עבורו.
מספק שמות מכשירים כמחרוזת.

rebootDevice () השתמש בפונקציה זו כדי לאתחל את המכשיר על ידי deviceHandle.
virtual ResultVoid nlc::NanoLibAccessor::rebootDevice (const DeviceHandle deviceHandle)

פרמטרים deviceHandle מחזירה ResultVoid

מציין את אוטובוס השדה לאתחול מחדש. מאשר שפונקציית בטל פעלה.

getDeviceState () השתמש בפונקציה זו כדי לקבל את המצב הספציפי למכשיר.
virtual ResultString nlc::NanoLibAccessor::getDeviceState (DeviceHandle const deviceHandle)

פרמטרים deviceHandle

מציין לאיזה מכשיר אוטובוס 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 ()
השתמש בפונקציה זו כדי לקבל את מצב החיבור הידוע האחרון של מכשיר ספציפי לפי deviceHandle (= מנותק, מחובר, ConnectedBootloader)
virtual ResultConnectionState nlc::NanoLibAccessor::getConnectionState (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultConnectionState

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את מצב החיבור.
מספק מצב חיבור (= מנותק, מחובר, ConnectedBootloader).

checkConnectionState ()
רק אם המצב האחרון הידוע לא היה מנותק: השתמש בפונקציה זו כדי לבדוק ואולי לעדכן את מצב החיבור של התקן ספציפי על ידי deviceHandle ועל ידי בדיקת מספר פעולות ספציפיות למצב.
virtual ResultConnectionState nlc::NanoLibAccessor::checkConnectionState (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultConnectionState

מציין לאיזה התקן אוטובוס NanoLib בודק את מצב החיבור.
מספק מצב חיבור (= לא מנותק).

assignObjectDictionary () השתמש בפונקציה הידנית הזו כדי להקצות מילון אובייקטים (OD) ל-deviceHandle בעצמך.
virtual ResultObjectDictionary nlc::NanoLibAccessor::assignObjectDictionary (DeviceHandle const deviceHandle, ObjectDictionary const & objectDictionary)

פרמטרים deviceHandle objectDictionary
מחזירה ResultObjectDictionary

מציין לאיזה מכשיר אוטובוס NanoLib מקצה את ה-OD. מציג את המאפיינים של מילון אובייקט.

autoAssignObjectDictionary ()
השתמש באוטומטיזם זה כדי לאפשר ל-NanoLib להקצות מילון אובייקטים (OD) ל-deviceHandle. בחיפוש וטעינת OD מתאים, NanoLib מקצה אותו אוטומטית למכשיר. הערה: אם OD תואם כבר נטען בספריית האובייקטים, NanoLib תשתמש בו באופן אוטומטי מבלי לסרוק את הספרייה שנשלחה.
virtual ResultObjectDictionary nlc::NanoLibAccessor::autoAssignObjectDictionary (DeviceHandle const deviceHandle, const std::string & dictionariesLocationPath)

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

פרמטרים deviceHandle

מחזיר

dictionariesLocationPath ResultObjectDictionary

מציין עבור איזה מכשיר אוטובוס NanoLib יסרוק אוטומטית לאיתור OD מתאים. מציין את הנתיב לספריית OD. מציג את המאפיינים של מילון אובייקט.

getAssignedObjectDictionary ()
השתמש בפונקציה זו כדי להקצות את מילון האובייקטים למכשיר באמצעות deviceHandle.
virtual ResultObjectDictionary nlc::NanoLibAccessor::getAssignedObjectDictionary (DeviceHandle const device
יָדִית)

פרמטרים deviceHandle מחזיר את ResultObjectDictionary

מציין לאיזה מכשיר אוטובוס NanoLib מקבל את ה-OD שהוקצה עבורו. מציג את המאפיינים של מילון אובייקט.

getObjectDictionaryLibrary () פונקציה זו מחזירה הפניה של OdLibrary.
Virtual OdLibrary& nlc::NanoLibAccessor::getObjectDictionaryLibrary ()

מחזיר OdLibrary&

פותח את כל ספריית ה-OD ואת מילוני האובייקטים שלה.

setLoggingLevel () השתמש בפונקציה זו כדי להגדיר את פירוט היומן הנדרש (ויומן file גודל). רמת ברירת המחדל היא מידע.
virtual void nlc::NanoLibAccessor::setLoggingLevel (רמת LogLevel)

רמת פרמטרים

פרטי היומן הבאים אפשריים:

0 = מעקב 1 = ניפוי באגים 2 = מידע 3 = אזהרה 4 = שגיאה 5 = קריטי 6 = כבוי

הרמה הנמוכה ביותר (יומן גדול ביותר file); רושם כל פרט אפשרי, בתוספת התחלה/עצירה של תוכנה. יומן מידע ניפוי באגים (= תוצאות ביניים, תוכן שנשלח או התקבל וכו') רמת ברירת מחדל; רושם הודעות מידע. יומן בעיות שאכן התרחשו אך לא יפסיק את האלגוריתם הנוכחי. יומן רק צרות קשות שאכן עצרו את האלגוריתם. הרמה הגבוהה ביותר (יומן הקטן ביותר file); מכבה את ההתנתקות; אין יומן נוסף בכלל. אין רישום כלל.

setLoggingCallback ()
השתמש בפונקציה זו כדי להגדיר מצביע התקשרות חזרה ביומן רישום ומודול יומן (= ספריה) עבור אותו התקשרות חוזרת (לא עבור לוגר עצמו).
virtual void nlc::NanoLibAccessor::setLoggingCallback (NlcLoggingCallback* callback, const nlc::LogModule & logModule)

פרמטרים *logback logModule

מגדיר מצביע להתקשרות חזרה. מכוון את ההתקשרות חזרה (לא לוגר!) לספרייה שלך.

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

מפעיל התקשרות חוזרת עבור הליבה של NanoLib בלבד. מפעיל התקשרות חוזרת של CANopen בלבד. מפעיל התקשרות חוזרת של Modbus בלבד. מפעיל התקשרות חוזרת של EtherCAT בלבד.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

4 = NanolibRest 5 = NanolibUSB

מפעיל התקשרות חוזרת של REST בלבד. מפעיל התקשרות חוזרת באמצעות USB בלבד.

unsetLoggingCallback () השתמש בפונקציה זו כדי לבטל מצביע להתקשרות חוזרת ברישום.
virtual void nlc::NanoLibAccessor::unsetLoggingCallback ()

readNumber () השתמש בפונקציה זו כדי לקרוא ערך מספרי ממילון האובייקט.
virtual ResultInt nlc::NanoLibAccessor::readNumber (const DeviceHandle deviceHandle, const OdIndex odIndex)

פרמטרים deviceHandle odIndex
מחזירה ResultInt

מציין מאיזה מכשיר אוטובוס NanoLib קורא. מציין את האינדקס (משנה) ממנו יש לקרוא. מספק ערך מספרי לא מפורש (ניתן לחתום, לא חתום, לתקן ערכי 16.16 סיביות).

readNumberArray () השתמש בפונקציה זו כדי לקרוא מערכים מספריים ממילון האובייקטים.
virtual ResultArrayInt nlc::NanoLibAccessor::readNumberArray (const DeviceHandle deviceHandle, const uint16_t index)

פרמטרים deviceHandle index
מחזירה את ResultArrayInt

מציין מאיזה מכשיר אוטובוס NanoLib קורא. אינדקס אובייקט מערך. מספק מערך שלמים.

readBytes () השתמש בפונקציה זו כדי לקרוא בתים שרירותיים (נתוני אובייקט תחום) ממילון האובייקטים.
virtual ResultArrayByte nlc::NanoLibAccessor::readBytes (const DeviceHandle deviceHandle, const OdIndex odIndex)

פרמטרים deviceHandle odIndex
מחזירה ResultArrayByte

מציין מאיזה מכשיר אוטובוס NanoLib קורא. מציין את האינדקס (משנה) ממנו יש לקרוא. מספק מערך בתים.

readString () השתמש בפונקציה זו כדי לקרוא מחרוזות מספריית האובייקטים.
virtual ResultString nlc::NanoLibAccessor::readString (const DeviceHandle deviceHandle, const OdIndex odIndex)

פרמטרים deviceHandle odIndex
מחזירה ResultString

מציין מאיזה מכשיר אוטובוס NanoLib קורא. מציין את האינדקס (משנה) שממנו יש לקרוא. מספק שמות מכשירים כמחרוזת.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

writeNumber () השתמש בפונקציה זו כדי לכתוב ערכים מספריים לספריית האובייקט.
virtual ResultVoid nlc::NanoLibAccessor::writeNumber (const DeviceHandle deviceHandle, int64_t value, const OdIndex odIndex, unsigned int bitLength)

פרמטרים deviceHandel ערך odIndex bitLength
מחזירה את ResultVoid

מציין לאיזה מכשיר אוטובוס NanoLib כותב. הערך הלא מפורש (ניתן לחתום, לא חתום, לתקן 16.16). מציין את האינדקס (משנה) ממנו יש לקרוא. אורך בסיביות. מאשר שפונקציית בטל פעלה.

writeBytes () השתמש בפונקציה זו כדי לכתוב בתים שרירותיים (נתוני אובייקט תחום) לספריית האובייקטים.
virtual ResultVoid nlc::NanoLibAccessor::writeBytes (const DeviceHandle deviceHandle, const std::vector & נתונים, const OdIndex odIndex)

פרמטרים deviceטיפול בנתונים odIndex
מחזירה את ResultVoid

מציין לאיזה מכשיר אוטובוס NanoLib כותב. וקטור / מערך בתים. מציין את האינדקס (משנה) ממנו יש לקרוא. מאשר שפונקציית בטל פעלה.

העלה קושחה ()
השתמש בפונקציה זו כדי לעדכן את קושחת הבקר שלך.
virtual ResultVoid nlc::NanoLibAccessor::uploadFirmware (const DeviceHandle deviceHandle, const std::vector & fwData, NlcDataTransferCallback* callback)

פרמטרים deviceHandle fwData NlcDataTransferCallback
מחזירה את ResultVoid

מציין איזה מכשיר אוטובוס NanoLib מעדכן. מערך המכיל נתוני קושחה. מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

uploadFirmwareFromFile ()
השתמש בפונקציה זו כדי לעדכן את קושחת הבקר שלך על ידי העלאת הקושחה שלה file.
virtual ResultVoid nlc::NanoLibAccessor::uploadFirmwareFromFile (const DeviceHandle deviceHandle, const std::string & absoluteFileנתיב, NlcDataTransferCallback* התקשרות חוזרת)

פרמטרים deviceHandle אבסולוטיFileנתיב NlcDataTransferCallback
מחזירה את ResultVoid

מציין איזה מכשיר אוטובוס NanoLib מעדכן. נתיב אל file המכיל נתוני קושחה (std::string). מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

UploadBootloader ()
השתמש בפונקציה זו כדי לעדכן את טוען האתחול של הבקר שלך.
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloader (const DeviceHandle deviceHandle, const std::vector & btData, NlcDataTransferCallback* callback)

פרמטרים deviceHandle btData NlcDataTransferCallback
מחזירה את ResultVoid

מציין איזה מכשיר אוטובוס NanoLib מעדכן. מערך המכיל נתוני אתחול. מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

uploadBootloaderFromFile ()
השתמש בפונקציה זו כדי לעדכן את טוען האתחול של הבקר שלך על ידי העלאתו file.
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloaderFromFile (const DeviceHandle deviceHandle, const std::string & bootloaderAbsoluteFileנתיב, NlcDataTransferCallback* התקשרות חוזרת)

פרמטרים deviceHandle BootloaderAbsoluteFileנתיב NlcDataTransferCallback
מחזירה את ResultVoid

מציין איזה מכשיר אוטובוס NanoLib מעדכן. נתיב אל file המכיל נתוני מאתחול (std::string). מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

uploadBootloaderFirmware ()
השתמש בפונקציה זו כדי לעדכן את טוען האתחול והקושחה של הבקר שלך.
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloaderFirmware (const DeviceHandle deviceHandle, const std::vector & btData, const std::vector & fwData, NlcDataTransferCallback* callback)

פרמטרים deviceHandle btData fwData NlcDataTransferCallback
מחזירה את ResultVoid

מציין איזה מכשיר אוטובוס NanoLib מעדכן. מערך המכיל נתוני אתחול. מערך המכיל נתוני קושחה. מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

uploadBootloaderFirmwareFromFile ()
השתמש בפונקציה זו כדי לעדכן את טוען האתחול והקושחה של הבקר שלך על ידי העלאת ה files.
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloaderFirmwareFromFile (const DeviceHandle deviceHandle, const std::string & bootloaderAbsoluteFileנתיב, const std::string & absoluteFileנתיב, NlcDataTransferCallback* התקשרות חוזרת)

פרמטרים deviceHandle BootloaderAbsoluteFileנתיב מוחלטFileנתיב NlcDataTransferCallback
מחזירה את ResultVoid

מציין איזה מכשיר אוטובוס NanoLib מעדכן. נתיב אל file המכיל נתוני מאתחול (std::string). נתיב אל file המכיל נתוני קושחה (uint8_t). מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

uploadNanoJ ()
השתמש בפונקציה ציבורית זו כדי להעלות את תוכנית NanoJ לבקר שלך.
virtual ResultVoid nlc::NanoLibAccessor::uploadNanoJ (DeviceHandle const deviceHandle, std::vector const & vmmData, NlcDataTransferCallback* callback)

פרמטרים deviceHandle vmmData NlcDataTransferCallback
מחזירה את ResultVoid

מציין לאיזה מכשיר אוטובוס NanoLib מעלה. מערך המכיל נתוני NanoJ. מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

uploadNanoJFromFile ()
השתמש בפונקציה ציבורית זו כדי להעלות את תוכנית NanoJ לבקר שלך על ידי העלאת file.
virtual ResultVoid nlc::NanoLibAccessor::uploadNanoJFromFile (const DeviceHandle deviceHandle, const std::string & absoluteFileנתיב, NlcDataTransferCallback* התקשרות חוזרת)

פרמטרים deviceHandle אבסולוטיFileנתיב NlcDataTransferCallback
מחזירה את ResultVoid

מציין לאיזה מכשיר אוטובוס NanoLib מעלה. נתיב אל file המכיל נתוני NanoJ (std::string). מעקב אחר התקדמות נתונים. מאשר שפונקציית בטל פעלה.

disconnectDevice () השתמש בפונקציה זו כדי לנתק את המכשיר שלך באמצעות deviceHandle.
virtual ResultVoid nlc::NanoLibAccessor::disconnectDevice (DeviceHandle const deviceHandle)

פרמטרים deviceHandle מחזירה ResultVoid

מציין מאיזה מכשיר אוטובוס NanoLib מתנתק. מאשר שפונקציית בטל פעלה.

removeDevice () השתמש בפונקציה זו כדי להסיר את המכשיר שלך מרשימת ההתקנים הפנימית של NanoLib.
virtual ResultVoid nlc::NanoLibAccessor::removeDevice (const DeviceHandle deviceHandle)

פרמטרים deviceHandle מחזירה ResultVoid

מציין איזה מכשיר אוטובוס NanoLib מסיר. מאשר שפונקציית בטל פעלה.

closeBusHardware () השתמש בפונקציה זו כדי להתנתק מחומרת אוטובוס השדה שלך.
virtual ResultVoid nlc::NanoLibAccessor::closeBusHardware (BusHardwareId const & busHwId)

פרמטרים busHwId מחזירה ResultVoid

מציין את אוטובוס השדה ממנו יש להתנתק. מאשר שפונקציית בטל פעלה.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

8.2 BusHardwareId
השתמש במחלקה זו כדי לזהות חומרת אוטובוס אחד לאחד או כדי להבחין בין חומרת אוטובוס שונה זו מזו. מחלקה זו (ללא פונקציות מגדיר שיהיו בלתי ניתנות לשינוי מהיצירה ואילך) מכילה גם מידע על:
חומרה (= שם מתאם, מתאם רשת וכו') פרוטוקול לשימוש (= 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). שם ידידותי (= AdapterName (Port) וכו').

BusHardwareId () [2/3] קונסטרוקטור שיוצר אובייקט מזהה חומרה אפיק חדש, עם אפשרות למפרט חומרה נוסף.
nlc::BusHardwareId::BusHardwareId (std::string const & busHardware_, std::string const & protocol_, std::string const & hardwareSpecifier_, std::string const & extraHardwareSpecifier_, std::string const & name_)

פרמטרים busHardware_ protocol_ hardwareSpecifier_ extraHardwareSpecifier_ name_

BusHardwareId () [3/3] קונסטרוקטור שמעתיק busHardwareId קיים.
nlc::BusHardwareId::BusHardwareId (BusHardwareId const &)

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

פרמטרים busHardwareId

נותן שמות של מזהה חומרת האוטובוס שממנו יש להעתיק.

שווה () משווה מזהה חומרת אוטובוס חדש לזה הקיים.
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 () מחזירה את מזהה החומרה של האוטובוס כמחרוזת.
std::string nlc::BusHardwareId::toString () const

מחזיר מחרוזת
8.3 BusHardwareOptions
מצא במחלקה זו, ברשימת מפתח-ערך של מחרוזות, את כל האפשרויות הדרושות לפתיחת חומרת אוטובוס.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

BusHardwareOptions () [1/2] בונה אובייקט חדש של אפשרות חומרת אוטובוס.
nlc::BusHardwareOptions::BusHardwareOptions () השתמש בפונקציה addOption () כדי להוסיף צמדי מפתח-ערך.

BusHardwareOptions () [2/2] בונה אובייקט חדש של אפשרויות חומרת אפיק עם מפת מפתח-ערך כבר במקום.
nlc::BusHardwareOptions::BusHardwareOptions (std::map קונסט ואפשרויות)

אפשרויות פרמטרים

מפה עם אפשרויות להפעלת חומרת האוטובוס.

addOption () יוצר מפתחות וערכים נוספים.
void nlc::BusHardwareOptions::addOption (std::string const & key, std::string const & value)

ערך מפתח פרמטרים

Example: BAUD_RATE_OPTIONS_NAME, ראה ברירת המחדל של bus_hw_options_
Example: BAUD_RATE_1000K, ראה bus_hw_options_defaults

שווה () משווה את BusHardwareOptions לאלה הקיימות.
bool nlc::BusHardwareOptions::שווה (BusHardwareOptions const ואחרים) const

פרמטרים אחרים מחזירה אמת
שֶׁקֶר

אובייקט נוסף מאותה מעמד. אם לאובייקט השני יש את כל אותן אפשרויות בדיוק. אם לאובייקט השני יש מפתחות או ערכים שונים.

getOptions () קורא את כל צמדי מפתח-ערך שנוספו.
std::map nlc::BusHardwareOptions::getOptions () const

מחזירה מפת מחרוזת

toString () מחזירה את כל המפתחות/ערכים כמחרוזת.
std::string nlc::BusHardwareId::toString () const

מחזיר מחרוזת
8.4 BusHwOptionsDefault
למחלקת אפשרויות תצורת ברירת המחדל הזו יש את התכונות הציבוריות הבאות:

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

const CanBus const סדרתי const RESTfulBus const EtherCATBus

canBus = CanBus () serial = Serial () restfulBus = RESTfulBus() ethercatBus = EtherCATBus()

8.5 CanBaudRate

מבנה המכיל תדרים של אוטובוס 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" = BAUD_RATE_100K ATE_50K = "50k" BAUD_RATE_20K = "20k" BAUD_RATE_10K = "10k"

8.6 CanBus

מחלקה ברירת מחדל של אפשרויות תצורה עם המאפיינים הציבוריים הבאים:

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_COMMUNICATION = "RESET_COMMUNICATION"

8.8 CanOpenNmtState

מבנה זה מכיל את מצבי CANopen NMT כערכי מחרוזת בתכונות הציבוריות הבאות:

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

STOPPED = "STOPPED" PRE_OPERATIONAL = "PRE_OPERATIONAL" OPERATIONAL = "מבצעי" אתחול = "אתחול" UNKNOWN = "לא ידוע"

8.9 מבנה EtherCATBus

מבנה זה מכיל את אפשרויות תצורת התקשורת של EtherCAT בתכונות הציבוריות הבאות:

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

const std::string NETWORK_FIRMWARE_STATE_OP- מצב רשת מטופל כמצב קושחה. קָבִיל

TION_NAME = "מצב קושחת הרשת"

ערכים (ברירת מחדל = PRE_OPERATIONAL):

EtherCATState::PRE_OPERATIONAL EtherCATState::SAFE_OPERATIONAL EtherCATState::OPERATIONAL

const std::string DEFAULT_NETWORK_FIRMWARE_ STATE = "PRE_OPERATIONAL"

const std::string EXCLUSIVE_LOCK_TIMEOUT_OP- פסק זמן באלפיות שניות לרכישת נעילה בלעדית

TION_NAME = "זמן קצוב נעילה משותפת"

הרשת (ברירת מחדל = 500 אלפיות השנייה).

const unsigned int DEFAULT_EXCLUSIVE_LOCK_ TIMEOUT = "500"

const std::string SHARED_LOCK_TIMEOUT_OPTION_ פסק זמן באלפיות שניות לרכישת נעילה משותפת

NAME = "זמן קצוב נעילה משותפת"

הרשת (ברירת מחדל = 250 אלפיות השנייה).

const unsigned int DEFAULT_SHARED_LOCK_TIMEOUT = "250"

const std::string READ_TIMEOUT_OPTION_NAME = פסק זמן באלפיות שניות עבור פעולת קריאה (ברירת מחדל

"פסק זמן לקריאה"

= 700 אלפיות השנייה).

const unsigned int DEFAULT_READ_TIMEOUT = "700"

const std::string WRITE_TIMEOUT_OPTION_NAME = פסק זמן באלפיות שניות עבור פעולת כתיבה (ברירת מחדל

"פסק זמן כתיבה"

= 200 אלפיות השנייה).

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 מבנה EtherCATState

מבנה זה מכיל את מצבי העבד / הרשת של 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" SAFE_OPERATIONAL = "SAFE_OPERATIONAL" OPERATIONAL = "OPERATIONAL"

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

8.11 Ixxat

מבנה זה מכיל את כל המידע עבור 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

מבנה זה מכיל את כל המידע עבור Peak usb-to-can בתכונות הציבוריות הבאות:

const std::string

ADAPTER_BUS_NUMBER_OPTIONS_NAME = "מספר אוטובוס מתאם שיא"

const PeakAdapterBusNumber adapterBusNumber = PeakAdapterBusNumber ()

8.14 PeakAdapterBusNumber

מבנה זה מכיל את מספר האוטובוס של Peak usb-to-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 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_string (PCAN_USBBUS:NUMBER_4) BUS_USBBUS_5) (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_USBBUS8) BUS_NUMBER_9 = std::to_string:מחרוזת_9_US:to_NUMBER:PCAN_US:string (PCAN_USBBUS10) BUS_NUMBER_10 = std::to_string (PCAN_USBBUS11) BUS_NUMBER_11 = std::to_string (PCAN_USBBUS12) BUS_NUMBER_12 = std::to_string (PCAN_USBBUS13) BUS_NUMBER_13_USBUS_14 = std_USBUS:::: std::to_string (PCAN_USBBUS14) BUS_NUMBER_15 = std::to_string (PCAN_USBBUS15)

8.15 DeviceHandle
מחלקה זו מייצגת ידית לשליטה במכשיר באוטובוס ויש לה את פונקציות החברים הציבוריות הבאות.

DeviceHandle () DeviceHandle (ידית uint32_t)

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

שווה () משווה את עצמו לידית התקן נתונה.
bool שווה (DeviceHandle const other) const (handled uint32_t)

toString () מחזירה ייצוג מחרוזת של ידית ההתקן.
std::string toString () const

get () מחזירה את ידית המכשיר.
uint32_t get () const

8.16 מזהה מכשיר
השתמש במחלקה זו (לא ניתן לשינוי מהיצירה ואילך) כדי לזהות ולהבחין בין מכשירים באוטובוס:

מזהה מתאם חומרה

מזהה מכשיר

תֵאוּר

המשמעות של ערכי מזהה מכשיר/תיאור תלויה באפיק. למשלample, אוטובוס CAN עשוי להשתמש במזהה השלם.

DeviceId () [1/3] בונה אובייקט מזהה מכשיר חדש.
nlc::DeviceId::DeviceId (BusHardwareId const & busHardwareId_, unsigned int deviceId_, std::string const & description_)

פרמטרים busHardwareId_ deviceId_ description_

מזהה של האוטובוס. אינדקס; בכפוף לאוטובוס (= מזהה צומת CANopen וכו'). תיאור (יכול להיות ריק); בכפוף לאוטובוס.

DeviceId () [2/3] בניית אובייקט מזהה מכשיר חדש עם אפשרויות מזהה מורחבות.
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 וכו'). תיאור (יכול להיות ריק); בכפוף לאוטובוס. תעודה מזהה נוספת (יכול להיות ריקה); המשמעות תלוי באוטובוס. מזהה מחרוזת נוסף (יכול להיות ריק); המשמעות תלוי באוטובוס.

DeviceId () [3/3] בונה עותק של אובייקט מזהה מכשיר.
nlc::DeviceId::DeviceId (DeviceId const &)

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

פרמטרים deviceId_

מזהה מכשיר להעתקה ממנו.

שווה () משווה חדש לאובייקטים קיימים.
bool nlc::DeviceId::שווה (DeviceId const ואחרים) const

מחזירה בוליאנית

getBusHardwareId () קורא את מזהה החומרה של האוטובוס.
BusHardwareId nlc::DeviceId::getBusHardwareId () const

מחזירה BusHardwareId

getDescription () קורא את תיאור המכשיר (אולי לא בשימוש).
std::string nlc::DeviceId::getDescription () const

מחזיר מחרוזת

getDeviceId () קורא את מזהה המכשיר (אולי לא בשימוש).
unsigned int nlc::DeviceId::getDeviceId () const

מחזיר int לא חתום

toString () מחזירה את האובייקט כמחרוזת.
std::string nlc::DeviceId::toString () const

מחזיר מחרוזת

getExtraId () קורא את המזהה הנוסף של המכשיר (ייתכן שלא נעשה בו שימוש).
const std::vector &getExtraId () const

מחזיר וקטור

וקטור של המזהים הנוספים הנוספים (יכול להיות ריק); המשמעות תלוי באוטובוס.

getExtraStringId () קורא את מזהה המחרוזת הנוסף של ההתקן (ייתכן שלא נעשה בו שימוש).
std::string getExtraStringId () const

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

מחזיר מחרוזת

מזהה המחרוזת הנוספת (יכול להיות ריק); המשמעות תלוי באוטובוס.

8.17 LogLevelConverter

מחלקה זו מחזירה את רמת היומן שלך כמחרוזת. סטטי std::string toString (nlc::LogLevel logLevel)

8.18 LogModuleConverter

מחלקה זו מחזירה את מודולי היומן הספציפיים לספרייה שלךLoggingLevel () כמחרוזת.

סטטי 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 index)

מחזירה ResultObjectEntry

מודיע על מאפייני אובייקט.

getXmlFileשם () וירטואלי ResultString getXmlFileשם () קונסט

מחזירה ResultString

מחזיר את ה-XML file שם כמחרוזת.

readNumber () וירטואלי ResultInt readNumber (OdIndex const odIndex) מחזירה ResultInt
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 odIndex) Result _const odIndex Return writeBytes () וירטואלי ResultVoid writeBytes (OdIndex const OdIndex, std::vector
const & data) מחזיר קישורים קשורים ResultVoid OdIndex
8.20 כניסת אובייקט
מחלקה זו מייצגת ערך אובייקט של מילון האובייקטים, בעלת התכונה המוגנת הסטטית ופונקציות חבר ציבורי:
static nlc::ObjectSubEntry invalidObject
getName () קורא את שם האובייקט כמחרוזת.
virtual std::string getName () const
getPrivate () בודק אם האובייקט פרטי.
virtual bool getPrivate () const
getIndex () קורא את הכתובת של אינדקס האובייקט.
virtual uint16_t getIndex () const

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

getDataType () קורא את סוג הנתונים של האובייקט.
virtual nlc::ObjectEntryDataType getDataType () const

getObjectCode () קורא את קוד האובייקט:

Null Deftype Defstruct Var Array Record

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

virtual nlc::ObjectCode getObjectCode () const

getObjectSaveable () בודק אם האובייקט ניתן לשמירה והקטגוריה שלו (ראה מדריך למוצר לפרטים נוספים): APPLICATION, COMMUNICATION, DRIVE, MISC_CONFIG, MODBUS_RTU, NO, TUNING, CUSTOMER, ETHERNET, CANOPEN, VERIFY1020, UNKNOWNTYPE_S
virtual nlc::ObjectSaveable getObjectSaveable () const

getMaxSubIndex () קורא את מספר תת-המדדים הנתמכים על ידי אובייקט זה.
virtual uint8_t getMaxSubIndex () const

getSubEntry () virtual nlc::ObjectSubEntry & getSubEntry (uint8_t subIndex)
ראה גם ObjectSubEntry.
8.21 ObjectSubEntry
מחלקה זו מייצגת תת-ערך של אובייקט (תת-אינדקס) של מילון האובייקטים ויש לה את הפונקציות הבאות של החברים הציבוריים:
getName () קורא את שם האובייקט כמחרוזת.
virtual std::string getName () const

getSubIndex () קורא את הכתובת של תת האינדקס.
virtual uint8_t getSubIndex () const

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

getDataType () קורא את סוג הנתונים של האובייקט.
virtual nlc::ObjectEntryDataType getDataType () const

getSdoAccess () בודק אם תת האינדקס נגיש דרך SDO:

קריאה בלבד

כתוב בלבד

ReadWrite

אין גישה

virtual nlc::ObjectSdoAccessAttribute getSdoAccess () const

getPdoAccess () בודק אם תת האינדקס נגיש/ניתן למיפוי באמצעות PDO:

TxRx

לֹא

virtual nlc::ObjectPdoAccessAttribute getPdoAccess () const

getBitLength () בודק את אורך המשנה.
virtual uint32_t getBitLength () const

getDefaultValueAsNumeric () קורא את ערך ברירת המחדל של תת האינדקס עבור סוגי נתונים מספריים.
virtual ResultInt getDefaultValueAsNumeric (std::string const & key) const

getDefaultValueAsString () קורא את ערך ברירת המחדל של תת האינדקס עבור סוגי נתוני מחרוזת.
וירטואלי ResultString getDefaultValueAsString (std::string const & key) const

getDefaultValues () קורא את ערכי ברירת המחדל של המשנה.
standard std::map getDefaultValues () const

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

readNumber () קורא את הערך הממשי המספרי של תת האינדקס.
virtual ResultInt readNumber () const

readString () קורא את הערך האמיתי של המחרוזת של תת האינדקס.
virtual ResultString readString () const

readBytes () קורא את הערך האמיתי של תת-האינדקס בבתים.
virtual ResultArrayByte readBytes () const

writeNumber () כותב ערך מספרי בתת אינדקס.
virtual ResultVoid writeNumber (ערך const int64_t) const

writeBytes () כותב ערך בתת אינדקס בבתים.
וירטואלי ResultVoid writeBytes (std::vector const & data) const

8.22 OdIndex
השתמש במחלקה זו (ניתנת לשינוי מהיצירה ואילך) כדי לעטוף ולאתר מדדי ספריית אובייקטים / תת-מדדים. ל-OD של התקן יש עד 65535 (0xFFFF) שורות ו-255 (0xFF) עמודות; עם פערים בין השורות הלא רציפות. עיין בתקן CANopen ובמדריך המוצר שלך לפרטים נוספים.
OdIndex () בונה אובייקט OdIndex חדש.
nlc::OdIndex::OdIndex (uint16_t index, uint8_t subIndex)

תת אינדקס אינדקס פרמטרים

מ-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

מחזירה 0xIII:0xSS

ייצוג מחרוזת ברירת מחדל

8.23 OdLibrary
השתמש בממשק תכנות זה כדי ליצור מופעים של המחלקה ObjectDictionary מ-XML. על ידי assignObjectDictionary, לאחר מכן תוכל לאגד כל מופע למכשיר ספציפי עקב מזהה שנוצר באופן ייחודי. מופעי ObjectDictionary שנוצרו כך מאוחסנים באובייקט OdLibrary כדי לגשת אליהם באמצעות אינדקס. המחלקה ODLibrary טוענת פריטי ObjectDictionary מ file או מערך, מאחסן אותם, ויש לו את פונקציות החברים הציבוריות הבאות:

getObjectDictionaryCount () וירטואלי uint32_t getObjectDictionaryCount () const

getObjectDictionary () וירטואלי ResultObjectDictionary getObjectDictionary (uint32_t odIndex)

מחזירה ResultObjectDictionary

addObjectDictionaryFromFile ()
Virtual ResultObjectDictionary addObjectDictionaryFromFile (std::string const & absoluteXmlFileנָתִיב)

מחזירה ResultObjectDictionary

addObjectDictionary ()
Virtual ResultObjectDictionary addObjectDictionary (std::vector const & odXmlData, const std::string &xmlFileנתיב = std::string ())

מחזירה ResultObjectDictionary
8.24 OdTypesHelper
בנוסף לפונקציות החברים הציבוריות הבאות, מחלקה זו מכילה סוגי נתונים מותאמים אישית. הערה: כדי לבדוק את סוגי הנתונים המותאמים אישית שלך, חפש את המחלקה enum ObjectEntryDataType ב-od_types.hpp.

uintToObjectCode () ממירה מספרים שלמים ללא סימנים לקוד אובייקט:

Null Deftype

0x00 0x05

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

הרס את רשומת Var Array

0x06 0x07 0x08 0x09

סטטי ObjectCode uintToObjectCode (לא חתום int objectCode)

isNumericDataType () מודיע אם סוג נתונים הוא מספרי או לא.
bool static isNumericDataType (ObjectEntryDataType dataType)

isDefstructIndex () מודיע אם אובייקט הוא אינדקס מבנה הגדרה או לא.
bool static isDefstructIndex (uint16_t typeNum)

isDeftypeIndex () מודיע אם אובייקט הוא אינדקס סוג הגדרה או לא.
bool static isDeftypeIndex (uint16_t typeNum)

isComplexDataType () מודיע אם סוג נתונים מורכב או לא.
bool static isComplexDataType (ObjectEntryDataType dataType)

uintToObjectEntryDataType () ממיר מספרים שלמים ללא סימנים לסוג נתונים OD.
sstatic ObjectEntryDataType uintToObjectEntryDataType (uint16_t objectDataType)

objectEntryDataTypeToString () ממיר סוג נתוני OD למחרוזת.
static std::string objectEntryDataTypeToString (ObjectEntryDataType odDataType)

stringToObjectEntryDatatype () ממיר מחרוזת לסוג נתונים OD במידת האפשר. אחרת, מחזיר את UNKNOWN_DATATYPE.
static ObjectEntryDataType stringToObjectEntryDatatype (std::string dataTypeString)

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

objectEntryDataTypeBitLength () מודיע על אורך הסיביות של סוג נתונים של הזנת אובייקט.
static uint32_t objectEntryDataTypeBitLength (ObjectEntryDataType const & dataType)

8.25 מבנה RESTfulBus

מבנה זה מכיל את אפשרויות תצורת התקשורת עבור ממשק RESTful (על Ethernet). הוא מכיל את המאפיינים הציבוריים הבאים:

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

CONNECT_TIMEOUT_OPTION_NAME = "זמן קצוב לחיבור רגוע" DEFAULT_CONNECT_TIMEOUT = 200 REQUEST_TIMEOUT_OPTION_NAME = "זמן קצוב של בקשה רגועה" DEFAULT_REQUEST_TIMEOUT = 200 RESPONSE_TIMEOUT_OPTION_NAME = "זמן קצוב לתגובה רגועה = פסק זמן של תגובה רגועה" DEFA750

8.26 ProfinetDCP
תחת לינוקס, היישום המתקשר זקוק ליכולות CAP_NET_ADMIN ו-CAP_NET_RAW. כדי להפעיל: sudo setcap 'cap_net_admin,cap_net_raw+eip' ./executable. ב-Windows, ממשק ProfinetDCP משתמש ב-WinPcap (נבדק עם גרסה 4.1.3) או Npcap (נבדק עם גרסאות 1.60 ו-1.30). לפיכך, הוא מחפש בספריית wpcap.dll הנטענת באופן דינמי בסדר הבא (הערה: אין תמיכה נוכחית ב-Win10Pcap):
1. ספריית Nanolib.dll 2. ספריית מערכת Windows SystemRoot%System32 3. ספריית ההתקנה של Npcap SystemRoot%System32Npcap 4. נתיב סביבה
מחלקה זו מייצגת ממשק Profinet DCP ויש לה את פונקציות החברים הציבוריות הבאות:

getScanTimeout () מודיע על פסק זמן של סריקת מכשיר (ברירת מחדל = 2000 אלפיות השנייה).
virtual uint32_t nlc::ProfinetDCP::getScanTimeout () const

setScanTimeout () מגדיר פסק זמן לסריקת התקן (ברירת מחדל = 2000 אלפיות השנייה).
virtual void nlc::setScanTimeout (uint32_t timeoutMsec)

getResponseTimeout () מודיע על פסק זמן לתגובה של המכשיר עבור פעולות הגדרה, איפוס והבהוב (ברירת מחדל = 1000 אלפיות השנייה).
virtual uint32_t nlc::ProfinetDCP::getResponseTimeout () const

setResponseTimeout () מודיע על פסק זמן לתגובת המכשיר עבור פעולות הגדרה, איפוס והבהוב (ברירת מחדל = 1000 אלפיות השנייה).
virtual void nlc::ProfinetDCP::setResponseTimeout (uint32_t timeoutMsec)

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

isServiceAvailable ()
השתמש בפונקציה זו כדי לבדוק את זמינות שירות Profinet DCP.
תוקף / זמינות מתאם רשת Windows: זמינות WinPcap / Npcap Linux: יכולות CAP_NET_ADMIN / CAP_NET_RAW
virtual ResultVoid nlc::ProfinetDCP::isServiceAvailable (const BusHardwareId & busHardwareId)

פרמטרים BusHardwareId מחזירה true
שֶׁקֶר

מזהה חומרה של שירות Profinet DCP לבדיקה. שירות זמין. השירות אינו זמין.

scanProfinetDevices () השתמש בפונקציה זו כדי לסרוק את אפיק החומרה לאיתור נוכחות של התקני Profinet.
Virtual ResultProfinetDevices scanProfinetDevices (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 שלו.
virtual ResultVoid nlc::blinkProfinetDevice (const BusHardwareId & busHardwareId, const ProfinetDevice &profinetDevice)

validateProfinetDeviceIp () השתמש בפונקציה זו כדי לבדוק את כתובת ה-IP של המכשיר.
virtual ResultVoid validateProfinetDeviceIp (const BusHardwareId &busHardwareId, const ProfinetDevice & profinetDevice)

פרמטרים BusHardwareId ProfinetDevice

מציין את מזהה החומרה שיש לבדוק. מציין את התקן Profinet לאימות.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

מחזירה את ResultVoid

8.27 מבנה ProfinetDevice

לנתוני מכשיר 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, מסיכת רשת ושער מתפרשים כולם כמספרי hex אנדיאנים גדולים, כגון:

כתובת IP: 192.168.0.2 מסיכת רשת: 255.255.0.0 שער: 192.168.0.1

0xC0A80002 0xFFFF0000 0xC0A80001

8.28 שיעורי תוצאה

השתמש בערכי ההחזרה ה"אופציונליים" של מחלקות אלה כדי לבדוק אם קריאת פונקציה הצליחה או לא, וגם לאתר את סיבות הכשל. עם הצלחה, הפונקציה hasError () מחזירה false. על ידי getResult (), אתה יכול לקרוא את ערך התוצאה לפי סוג (ResultInt וכו'). אם שיחה נכשלת, אתה קורא את הסיבה באמצעות getError ().

תכונות מוגנות

מחרוזת NlcErrorCode uint32_t

errorString errorCode exErrorCode

כמו כן, למחלקה זו יש את פונקציות החברים הציבוריות הבאות:

hasError () קורא את ההצלחה של קריאת פונקציה.
bool nlc::Result::hasError () const

מחזיר

נכון שקר

שיחה נכשלה. השתמש ב-getError () כדי לקרוא את הערך. שיחה מוצלחת. השתמש ב-getResult () כדי לקרוא את הערך.

getError () קורא את הסיבה אם קריאת פונקציה נכשלת.
const std::string nlc::Result::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
8.28.1 ResultVoid
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 (קונסט ותוצאה של תוצאה)
8.28.2 ResultInt
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה מספר שלם. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () מחזירה את תוצאת המספר השלם אם קריאת פונקציה הצליחה.
int64_t getResult () const
מחזירה int64_t

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות
ResultInt () הפונקציות הבאות מסייעות בהגדרת התוצאה המדויקת של מספר שלם:
ResultInt (int64_t result_)
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 (קונסט ותוצאה של תוצאות)
8.28.3 ResultString
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 ResultArrayByte
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה מערך בתים. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את וקטור הבתים אם קריאת פונקציה הצליחה.
const std::vector nlc::ResultArrayByte::getResult () const
מחזיר וקטור const

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות
ResultArrayByte () הפונקציות הבאות מסייעות בהגדרת התוצאה המדויקת של מערך הבתים:
ResultArrayByte (std::vector קונסט ותוצאה_)
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 (קונסט ותוצאה של תוצאות)
8.28.5 ResultArrayInt
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה מערך שלמים. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את וקטור המספר השלם אם קריאת פונקציה הצליחה.
const std::vector nlc::ResultArrayInt::getResult () const
מחזיר וקטור const
ResultArrayInt () הפונקציות הבאות מסייעות בהגדרת תוצאת המערך המדויק של מספר שלם:
ResultArrayInt (std::vector קונסט ותוצאה_)
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 (קונסט ותוצאה של תוצאות)
8.28.6 ResultBusHwIds
NanoLib שולחת לך מופע של מחלקה זו אם הפונקציה מחזירה מערך מזהה חומרת אוטובוס. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את וקטור ה-bus-hardware-ID אם קריאת פונקציה הצליחה.
const std::vector nlc::ResultBusHwIds::getResult () const
פרמטרים const וקטור

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות
ResultBusHwIds () הפונקציות הבאות מסייעות בהגדרת התוצאה המדויקת של Bus-hardware-ID-Array:
ResultBusHwIds (std::vector קונסט ותוצאה_)
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 ResultDeviceId
NanoLib שולחת לך מופע של מחלקה זו אם הפונקציה מחזירה מזהה מכשיר. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את וקטור מזהה המכשיר אם קריאת פונקציה הצליחה.
DeviceId nlc::ResultDeviceId::getResult () const
מחזיר וקטור const
ResultDeviceId () הפונקציות הבאות מסייעות בהגדרת התוצאה המדויקת של מזהה המכשיר:
ResultDeviceId (DeviceId const & result_)
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 ResultDeviceIds
NanoLib שולחת לך מופע של מחלקה זו אם הפונקציה מחזירה מערך מזהה מכשיר. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () מחזירה את וקטור מזהה המכשיר אם קריאת פונקציה הצליחה.
DeviceId nlc::ResultDeviceIds::getResult () const
מחזיר וקטור const

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות
ResultDeviceIds () הפונקציות הבאות מסייעות בהגדרת התוצאה המדויקת של מכשיר מזהה מערך:
ResultDeviceIds (std::vector קונסט ותוצאה_)
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 ResultDeviceHandle
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה את הערך של נקודת אחיזה במכשיר. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את ידית המכשיר אם קריאת פונקציה הצליחה.
DeviceHandle nlc::ResultDeviceHandle::getResult () const
מחזיר את DeviceHandle
ResultDeviceHandle () הפונקציות הבאות מסייעות בהגדרת התוצאה המדויקת של ידית ההתקן:
ResultDeviceHandle (DeviceHandle const & result_)
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 (קונסט ותוצאה של תוצאות)
8.28.10 ResultObjectDictionary
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה את התוכן של מילון אובייקט. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את וקטור מזהה המכשיר אם קריאת פונקציה הצליחה.
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 (קונסט ותוצאה של תוצאות)

8.28.11 ResultConnectionState
NanoLib שולחת לך מופע של מחלקה זו אם הפונקציה מחזירה מידע על התקן-חיבור-מצב. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את ידית המכשיר אם קריאת פונקציה הצליחה.
DeviceConnectionStateInfo nlc::ResultConnectionState::getResult () const

מחזירה DeviceConnectionStateInfo מחובר / מנותק / ConnectedBootloader

ResultConnectionState () הפונקציות הבאות מסייעות בהגדרת תוצאת מצב החיבור המדויקת:
ResultConnectionState (DeviceConnectionStateInfo const & result_)

ResultConnectionState (std::string const & errorString_)

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

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

ResultConnectionState (קונסט ותוצאה של תוצאה)

8.28.12 ResultObjectEntry
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה ערך אובייקט. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות
getResult () מחזירה את וקטור מזהה המכשיר אם קריאת פונקציה הצליחה.
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 ResultObjectSubEntry
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה ערך משנה של אובייקט. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () מחזירה את וקטור מזהה המכשיר אם קריאת פונקציה הצליחה.
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 ResultProfinetDevices
NanoLib שולחת לך מופע של מחלקה זו אם הפונקציה מחזירה התקן Profinet. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

getResult () קורא את וקטור ההתקן של Profinet אם קריאת פונקציה הצליחה.
const std::vector & getResult () const

ResultProfinetDevices () הפונקציות הבאות מסייעות בהגדרת התקני Profinet המדויקים.
ResultProfinetDevices (const std::vector & profinetDevices)
ResultProfinetDevices (קונסט תוצאה ותוצאה)
ResultProfinetDevices (const std::string &errorText, NlcErrorCode errorCode = NlcErrorCode::GeneralError, uint32_t extendedErrorCode = 0)
8.28.15 תוצאותampleDataArray
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה כampמערך הנתונים. המחלקה יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:
getResult () קורא את מערך הנתונים אם קריאת פונקציה הצליחה.
const std::vector <SampleData> & getResult () const

תוצאותampleDataArray () הפונקציות הבאות מסייעות בהגדרת התקני Profinet המדויקים.
תוצאות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 (תוצאה ותוצאה)

8.28.16 תוצאותamplerState
NanoLib שולח לך מופע של מחלקה זו אם הפונקציה מחזירה כampler state. מחלקה זו יורשת את הפונקציות הציבוריות / התכונות המוגנות ממחלקת התוצאה ויש לה את פונקציות החברים הציבוריות הבאות:

getResult () קורא את ה-sampוקטור מצב ler אם קריאת פונקציה הצליחה.
SamplerState getResult () const

מחזיר את סamplerState>

לא מוגדר / מוגדר / מוכן / פועל / הושלם / נכשל / מבוטל

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

תוצאותamplerState () הפונקציות הבאות מסייעות בהגדרת ה-s המדויקampמדינת לר.
תוצאותamplerState (קונסט סampמדינת lerState)

תוצאותamplerState (const std::string & errorDesc, const NlcErrorCode errorCode = NlcErrorCode::GeneralError, const uint32_t
extendedErrorCode = 0)

תוצאותamplerState (const ResultSamplerState ואחרים)

תוצאותamplerState (תוצאה ותוצאה קבועה)

8.29 NlcErrorCode

אם משהו משתבש, מחלקות התוצאה מדווחות על אחד מקודי השגיאה המפורטים בספירה זו.

קוד שגיאה הצלחה כללישגיאה BusUnaavailable CommunicationError ProtocolError
ODDoesNotExist ODInvalidAccess ODTypeIsmatch Operation Aborted OperationNotSupported InvalidOperation
InvalidArguments AccessDenied ResourceNotFound ResourceUnaavailable OutOfMemory TimeOutError

C: קטגוריה D: תיאור R: סיבה C: אין. D: אין שגיאה. R: הפעולה הושלמה בהצלחה.
ג: לא מוגדר. D: שגיאה לא מוגדרת. R: כישלון שלא מתאים לאף קטגוריה אחרת.
ג: אוטובוס. D: אוטובוס חומרה אינו זמין. R: אוטובוס לא קיים, מנותק או פגום.
ג: תקשורת. D: תקשורת לא אמינה. R: נתונים לא צפויים, CRC שגוי, שגיאות מסגרת או זוגיות וכו'.
ג: פרוטוקול. D: שגיאת פרוטוקול. R: תגובה לאחר אפשרות פרוטוקול לא נתמך, דוח התקן לא נתמך בפרוטוקול, שגיאה בפרוטוקול (למשל, SDO קטע סנכרון סיביות) וכו'. R: תגובה או דוח התקן לפרוטוקול לא נתמך (אפשרויות) או לשגיאות בפרוטוקול (למשל, SDO סיביות סינכרון מקטעים) וכו'. R: פרוטוקול לא נתמך (אפשרויות) או שגיאה בפרוטוקול (נגיד, סיביות סינכרון מקטע SDO) וכו'.
ג: מילון חפצים. D: כתובת OD לא קיימת. ר: אין כתובת כזו במילון האובייקט.
ג: מילון חפצים. D: גישה לכתובת OD לא חוקית. ר: נסה לכתוב קריאה בלבד, או לקרוא מכתובת לכתיבה בלבד.
ג: מילון חפצים. D: אי התאמה של סוג. R: ערך לא הומר לסוג שצוין, למשל, בניסיון להתייחס למחרוזת כמספר.
ג: יישום. D: התהליך הופסק. R: תהליך חתוך לפי בקשת בקשה. חוזר רק על הפרעת פעולה על ידי פונקציית התקשרות חוזרת, למשל, מסריקת אוטובוס.
ג: נפוץ. D: התהליך אינו נתמך. R: אין תמיכה באפיק חומרה/התקן.
ג: נפוץ. D: תהליך שגוי בהקשר הנוכחי, או לא חוקי עם הארגומנט הנוכחי. R: ניסיון חיבור מחדש לאוטובוסים/מכשירים שכבר מחוברים. ניסיון ניתוק לאלה שכבר מנותקים. ניסיון פעולה של טוען אתחול במצב קושחה או להיפך.
ג: נפוץ. ד: טיעון לא חוקי. R: לוגיקה או תחביר שגויים.
ג: נפוץ. D: הגישה נדחתה. R: היעדר זכויות או יכולות לבצע את הפעולה המבוקשת.
ג: נפוץ. D: הפריט שצוין לא נמצא. R: אפיק חומרה, פרוטוקול, התקן, כתובת OD במכשיר, או file לא נמצא.
ג: נפוץ. D: הפריט שצוין לא נמצא. R: עסוק, לא קיים, מנותק או פגם.
ג: נפוץ. D: זיכרון לא מספיק. R: מעט מדי זיכרון לעיבוד פקודה זו.
ג: נפוץ. D: הזמן הקצוב לתהליך. R: החזרה לאחר תום פסק הזמן. הזמן הקצוב עשוי להיות זמן תגובה של המכשיר, זמן לקבל גישה למשאבים משותפת או בלעדית, או זמן להעביר את האוטובוס/המכשיר למצב מתאים.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

8.30 NlcCallback
למחלקה אב זו להתקשרות חוזרת יש את פונקציית החברים הציבורית הבאה: callback ()
התקשרות חוזרת וירטואלית ResultVoid ()

מחזיר

ResultVoid

8.31 NlcDataTransferCallback
השתמש במחלקת התקשרות חוזרת זו להעברת נתונים (עדכון קושחה, העלאת NanoJ וכו'). 1. להעלאת קושחה: הגדר "מחלקה משותפת" שמרחיב את זה עם שיטת התקשרות חוזרת מותאמת אישית
יישום. 2. השתמש במופעים של "co-class" בקריאות NanoLibAccessor.uploadFirmware (). למחלקה הראשית עצמה יש את פונקציית החברים הציבורית הבאה:

callback () וירטואלי ResultVoid callback (nlc::DataTransferInfo info, int32_t data)

מחזיר

ResultVoid

8.32 NlcScanBusCallback
השתמש במחלקת התקשרות חוזרת זו לסריקת אוטובוס. 1. הגדר "מחלקה משותפת" שמרחיב את זה עם יישום שיטת התקשרות חוזרת מותאמת אישית. 2. השתמש במופעים של "co-class" בקריאות NanoLibAccessor.scanDevices (). למחלקה הראשית עצמה יש את פונקציית החברים הציבורית הבאה.

התקשר חזרה ()
וירטואלי ResultVoid התקשרות חוזרת (nlc::BusScanInfo info, std::vector const & devicesFound, int32_t data)

מחזירה את ResultVoid
8.33 NlcLoggingCallback
השתמש במחלקת התקשרות חוזרת זו לרישום התקשרויות חוזרות. 1. הגדר מחלקה שמרחיבה מחלקה זו עם יישום שיטת התקשרות מותאמת אישית 2. השתמש במצביע למופעים שלה על מנת להגדיר התקשרות חוזרת על ידי NanoLibAccessor >
setLoggingCallback (...).
callback וירטואלי (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 Sampממשק ler
השתמש במחלקה זו כדי להגדיר, להתחיל ולעצור את ה-sampler, או לקבל סampנתוני הוביל ואחזר כampמצבו של ler או השגיאה האחרונה. לכיתה יש את פונקציות החברים הציבוריות הבאות.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

configure () מגדיר כampלר.
virtual ResultVoid nlc::SamplerInterface::configure (const DeviceHandle deviceHandle, const SamplerConfiguration & samplerConfiguration)

פרמטרים [in] deviceHandle [in] samplerConfiguration
מחזירה את ResultVoid

מציין איזה מכשיר להגדיר את ה-sampלר עבור. מציין את הערכים של תכונות התצורה. מאשר שפונקציית בטל פעלה.

getData () מקבל את ה-sampנתונים מובילים.
תוצאות וירטואליותampleDataArray nlc::SamplerInterface::getData (const DeviceHandle deviceHandle)

פרמטרים [ב] deviceHandle מחזירה ResultSampleDataArray

מציין לאיזה מכשיר יש לקבל את הנתונים.
מספק את ה-sampנתוני led, שיכולים להיות מערך ריק אם samplerNotify פעיל בהתחלה.

getLastError () מקבל כמוampהשגיאה האחרונה של לר.
virtual ResultVoid nlc::SamplerInterface::getLastError (const DeviceHandle deviceHandle)

מחזירה את ResultVoid

מאשר שפונקציית בטל פעלה.

getState () מקבל כמוampמעמדו של לר.
תוצאות וירטואליותamplerState nlc::SamplerInterface::getState (const DeviceHandle deviceHandle)

מחזיר תוצאותamplerState

מספק את ה-sampמדינת לר.

התחל () מתחיל בתורampלר.
virtual ResultVoid nlc::SamplerInterface::start (const DeviceHandle deviceHandle, SamplerNotify* samplerNotify, int64_t applicationData)

פרמטרים [ב] deviceHandle [in] SamplerNotify [ב] applicationData
מחזירה את ResultVoid

מציין איזה מכשיר להפעיל את ה-sampלר עבור.
מציין איזה מידע אופציונלי לדווח (יכול להיות nullptr).
אפשרות: מעביר נתונים הקשורים לאפליקציה (מערך 8 סיביות המוגדר על ידי ערך / מזהה מכשיר / אינדקס, או תאריך ושעה, מצביע של משתנה / פונקציה וכו') ל-samplerNotify.
מאשר שפונקציית בטל פעלה.

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

עצור () מפסיק כמוampלר.
virtual ResultVoid nlc::SamplerInterface::stop (const DeviceHandle deviceHandle)

פרמטרים [ב] deviceHandle מחזירה ResultVoid

מציין איזה מכשיר לעצור את ה-sampלר עבור. מאשר שפונקציית בטל פעלה.

8.35 SamplerConfiguration struct

מבנה זה מכיל את הנתונים sampאפשרויות התצורה של ler (סטטיות או לא).

תכונות ציבוריות

std::vector כתובות במעקב

עד 12 כתובות OD להיות sampלד.

uint32_t

גִרְסָה

גרסה של מבנה.

uint32_t

משך מילישניות

Sampמשך לינג ב-ms, מ-1 עד 65535

uint16_t

תקופה מילישניות

Sampתקופת לינג ב- ms.

uint16_t

numberOfSamples

Sampפחות כמות.

uint16_t

preTriggerNumberOfSamples

Sampכמות קדם ההדק.

bool

באמצעות יישום תוכנה

השתמש ביישום תוכנה.

bool

באמצעות NewFWSamplerImplementation השתמש ביישום FW עבור מכשירים עם א

גרסת FW v24xx ומעלה.

SamplerMode

מצב

s רגיל, חוזר או רציף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_GREATER_GREATER_GREATER_0 TC_GREATERQUARTER = 15x0 TC_LESS = 16x0 TC_LESS_OR_EQUAL = 17x0 TC_EQUAL = 18x0 TC_NOT_EQUAL = 19x0A TC_ONE_EDGE = 1x0B TC_MULTI_EDGE = 1x0C, OdIndex, TriggerValuex,

SamplerTrigger

טריגר להתחיל בתורampלר?

תכונות ציבוריות סטטיות
static constexpr size_t SAMPLER_CONFIGURATION_VERSION = 0x01000000 סטטי constexpr size_t MAX_TRACKED_ADDRESSES = 12
8.36 SamplerNotify
השתמש במחלקה זו כדי להפעיל את sampהודעות ler כאשר אתה מתחיל בתורampלר. לכיתה יש את פונקציית החבר הציבורי הבאה.

גרסה: 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 applicationData)

פרמטרים [ב] lastError [ב] samplerState
[ב] סampleDatas [ב] applicationData

מדווח על השגיאה האחרונה שהתרחשה בזמן שampling. מדווח ה-sampמצב ler בזמן ההתראה: לא מוגדר / מוגדר / מוכן / פועל / הושלם / נכשל / בוטל. מדווח ה-sampמערך נתוני led. מדווח על נתונים ספציפיים לאפליקציה.

8.37 Sampמבנה leData

מבנה זה מכיל את ה-sampנתונים מובילים.

uin64_t iterationNumber

מתחיל ב-0 ועולה רק במצב חזרתי.

std::vector<SampledValues> מכיל מערך של sampערכי led.

8.38 Sampמבנה ledValue

מבנה זה מכיל את ה-sampערכי led.

ערך in64_t uin64_t CollectTimeMsec

מכיל את הערך של כתובת OD במעקב.
מכיל את זמן האיסוף באלפיות שניות, ביחס ל-sampההתחלה.

8.39 SamplerTrigger struct

מבנה זה מכיל את הגדרות ההדק של ה-sampלר.

Sampמצב lerTriggerCondition
ערך 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_GREAOR0 TC_GREATER15 0x16 TC_LESS = 0x17 TC_LESS_OR_EQUAL = 0x18 TC_EQUAL = 0x19 TC_NOT_EQUAL = 0x1A TC_ONE_EDGE = 0x1B TC_MULTI_EDGE = 0x1C
ה-OdIndex של הדק (כתובת).
ערך תנאי או מספר סיביות (החל מבביט אפס).

8.40 מבנה סדרתי

מצא כאן את אפשרויות התקשורת הטורית שלך ואת המאפיינים הציבוריים הבאים:

const std::string const SerialBaudRate

BAUD_RATE_OPTIONS_NAME = "קצב שידור טורי" baudRate =מבנה קצב העברת נתונים סדרתי

גרסה: doc 1.4.2 / NanoLib 1.3.0

8 מחלקות / פונקציות התייחסות

const std::string const SerialParity

PARITY_OPTIONS_NAME = זוגיות "סדרתית" = מבנה SerialParity

8.41 מבנה SerialBaudRate

מצא כאן את קצב העברת התקשורת הטורית שלך ואת המאפיינים הציבוריים הבאים:

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" "56000_56000_RATE" = "57600_57600_" 115200" BAUD_RATE_115200 = "128000" BAUD_RATE_128000 = "256000" BAUD_RATE_256000 = "XNUMX"

8.42 מבנה SerialParity

מצא כאן את אפשרויות השוויון הסדרתי שלך ואת המאפיינים הציבוריים הבאים:

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

NONE = "אף אחד" ODD = "מוזר" EVEN = "זוגי" MARK = "סמן" SPACE = "רווח"

גרסה: doc 1.4.2 / NanoLib 1.3.0

9 רישיונות

כותרות ממשק NanoLib API ודוגמאותampקוד המקור מורשים על ידי Nanotec Electronic GmbH & Co. KG תחת רישיון Creative Commons Attribution 3.0 Unported (CC BY). חלקי הספרייה הניתנים בפורמט בינארי (ספריות תקשורת ליבה ושדה-אוטובוס) מורשים תחת הרישיון הבינלאומי Creative Commons AttributionNoDerivatives 4.0 (CC BY ND).

קריאייטיב קומונס
התקציר הבא לקריאה אנושי לא יחליף את הרישיונות עצמם. אתה יכול למצוא את הרישיון המתאים ב-creativecommons.org ובקישור למטה. אתה חופשי:

CC BY 3.0
שתף: ראה ימינה. התאם: לערבב מחדש, להפוך, ולבנות על
חומר לכל מטרה, אפילו מסחרית.

CC BY-ND 4.0
שתף: העתק והפצה מחדש של החומר בכל מדיום או פורמט.

נותן הרישיון אינו יכול לבטל את החירויות הנ"ל כל עוד אתה מציית לתנאי הרישיון הבאים:

CC BY 3.0

CC BY-ND 4.0

ייחוס: עליך לתת קרדיט מתאים, ייחוס: ראה משמאל. אבל: תן קישור לזה

ספק קישור לרישיון וציין אם

רישיון אחר.

נעשו שינויים. אתה יכול לעשות זאת בכל

ללא נגזרות: אם אתה מיקס, ממיר או בונה

בצורה סבירה, אבל לא בשום אופן שמציע-

על החומר, אינך רשאי להפיץ את

מודה שמעניק הרישיון מאשר אותך או את השימוש שלך.

חומר שונה.

אין הגבלות נוספות: אינך רשאי להחיל. אין הגבלות נוספות: ראה משמאל. מונחים משפטיים או אמצעים טכנולוגיים שמבחינה חוקית

להגביל אחרים מלעשות כל דבר ברישיון

היתרים.

הערה: אינך חייב לציית לרישיון עבור רכיבים של החומר הנמצאים ברשות הציבור או היכן שהשימוש שלך מותר על פי חריג או הגבלה רלוונטיים.
הערה: לא ניתנה אחריות. ייתכן שהרישיון לא יעניק לך את כל ההרשאות הדרושות לשימוש המיועד שלך. למשלampזכויות אחרות כגון פרסום, פרטיות או זכויות מוסריות עשויות להגביל את אופן השימוש שלך בחומר.

גרסה: 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: תמיכה במתאם Peak PCAN-USB (IPEH-002021/002022).
> ליבת NanoLib: שינוי ממשק התקשרות חוזרת ברישום (LogLevel הוחלף ב-LogModule). # לוגר NanoLib: ההפרדה בין הליבה והמודולים תוקנה. # Modbus TCP: עדכון קושחה קבוע עבור FW4. # EtherCAT: העלאת תוכנית NanoJ קבועה עבור Core5. # EtherCAT: עדכון קושחה קבוע עבור Core5.
# Modbus RTU: תיקנו בעיות תזמון עם קצבי שידור נמוכים במהלך עדכון קושחה. # רגוע: העלאת תוכנית NanoJ קבועה.
# מודולי NanoLib Sampלר: קריאה נכונה של ס'ampהובילו ערכים בוליאניים.
+ תמיכה ב-Java 11 לכל הפלטפורמות. + תמיכה ב-Python 3.11/3.12 לכל הפלטפורמות. + ממשק התקשרות חזרה ברישום חדש (ראה למשלamples). + כיורי Callback עבור NanoLib לוגר. > עדכון לוגר לגרסה 1.12.0. > NanoLib Modules Sampler: תמיכה כעת בקושחת בקר Nanotec v24xx. > NanoLib Modules Sampler: שינוי במבנה המשמש עבור sampתצורת ler. > NanoLib Modules Sampler: מצב מתמשך הוא שם נרדף לאינסופי; מצב ההדק נבדק פעם אחת; מספר samples חייב להיות 0. > NanoLib Modules Sampler: עדיפות רגילה עבור השרשור שאוסף נתונים במצב קושחה. > NanoLib Modules Sampler: אלגוריתם משוכתב לזיהוי מעבר בין מצב מוכן והפעלה. # ליבת NanoLib: לא עוד הפרת גישה (0xC0000005) בסגירת 2 מכשירים או יותר המשתמשים באותה חומרת אפיק. # ליבת NanoLib: לא עוד תקלת פילוח בחיבור מתאם PEAK תחת לינוקס. # NanoLib Modules Sampלר: נכון סampקריאת ערכי led במצב קושחה. # NanoLib Modules Sampler: תצורה נכונה של 502X:04. # NanoLib Modules Sampler: ערבוב נכון של חוצצים עם ערוצים. # NanoLib-Canopen: זמן קצוב CAN מוגבר עבור חוסן וסריקה נכונה בקצבים נמוכים יותר. # NanoLib-Modbus: אלגוריתם זיהוי VCP עבור מכשירים מיוחדים (USB-DA-IO).
+ תמיכה ב-EtherCAT.
+ הערה על הגדרות פרויקט VS ב-Configure Project.
+ getDeviceHardwareGroup (). + getProfinetDCP (isServiceAvailable). + getProfinetDCP (validateProfinetDeviceIp). + autoAssignObjectDictionary (). + getXmlFileשם (). + const std::string & xmlFileנתיב ב-addObjectDictionary (). + getSamplerInterface ().

מוצר 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

+ נוסף > השתנה # קבוע + אתחול מחדש (). + קוד שגיאה ResourceUnaavailable עבור getDeviceBootloaderVersion (), ~VendorId (), ~HardwareVersion (), ~SerialNumber ו-~Uid. > firmwareUploadFromFile כעת העלה FirmwareFromFile (). > FirmwareUpload () העלה כעת Firmware (). > bootloaderUploadFromFile () עכשיו uploadBootloaderFromFile (). > bootloaderUpload () עכשיו העלהBootloader (). > BootloaderFirmwareUploadFromFile () כדי להעלות אתBootloaderFirmwareFromFile (). > bootloaderFirmwareUpload () העלה כעתBootloaderFirmware (). > nanojUploadFromFile () עכשיו העלה אתNanoJFromFile (). > nanojUpload () עכשיו העלהNanoJ (). > objectDictionaryLibrary () עכשיו getObjectDictionaryLibrary (). > String_String_Map עכשיו StringStringMap. > NanoLib-Common: הפעלה מהירה יותר של listAvailableBusHardware ו-openBusHardwareWithProtocol עם מתאם Ixxat. > NanoLib-CANopen: נעשה שימוש בהגדרות ברירת המחדל (1000k baudrate, אוטובוס Ixxat מספר 0) אם אפשרויות חומרת האוטובוס ריקות. > NanoLib-RESTful: הרשאת מנהל מיושנת לתקשורת עם מטעני אתחול Ethernet תחת Windows אם מנהל התקן npcap / winpcap זמין. # NanoLib-CANopen: חומרת האוטובוס נפתחת כעת ללא התרסקות עם אפשרויות ריקות. # NanoLib-Common: openBusHardwareWithProtocol () ללא דליפת זיכרון כעת.
+ תמיכה ב-Linux ARM64. + תמיכה באחסון המוני USB / REST / Profinet DCP. + checkConnectionState (). + getDeviceBootloaderVersion (). + ResultProfinetDevices. + NlcErrorCode (החליף את NanotecExceptions). + NanoLib Modbus: רכזת VCP / USB מאוחדת ל-USB. > סריקת Modbus TCP מחזירה תוצאות. < זמן השהיה לתקשורת Modbus TCP נשאר קבוע.
+ עוד ObjectEntryDataType (מורכב ומקצועיfile-ספֵּצִיפִי). + IOError return אם connectDevice () ו- scanDevices () לא מוצאים. + פסק זמן נומינלי של 100 אלפיות השנייה בלבד עבור CanOpen / Modbus.
+ תמיכת Modbus (בתוספת USB Hub באמצעות VCP). + פרק יצירת פרויקט לינוקס משלך. + extraHardwareSpecifier ל-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

מסמכים / משאבים

תכנות ננוטיק NanoLib C++ [pdfמדריך למשתמש
NanoLib תכנות C, תכנות C, תכנות

הפניות

מדריך למשתמש

תכנות ננוטיק NanoLib C++

מידע על המוצר

הוראות שימוש במוצר

שאלות נפוצות

תיעוד מטרה ומוסכמות

לפני שמתחילים

ארכיטקטורת NanoLib

מתחילים

מתחיל את האקסampלפרויקט

יצירת פרויקט Windows משלך

חותם, קשר, גרסאות

מסמכים / משאבים

הפניות

השאר תגובה

בטל תשובה