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

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

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

ציוד לבית חכם

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

1. חיישנים המודדים פרמטרים סביבתיים שונים;
2. מפעילים הפועלים על עצמים חיצוניים;
3. בקר המבצע חישובים בהתאם למדידות חיישנים וללוגיקה משובצת, ומוציא פקודות למפעילים.

באיור הבא ניתן לראות תרשים של בית חכם, עליו ישנם חיישנים לנזילת מים (1) בחדר האמבטיה, טמפרטורה (2) ותאורה (3) בחדר השינה, שקע חכם (4) במטבח ו- מצלמת מעקב וידאו (5) במסדרון.

כיום, חיישנים אלחוטיים הפועלים באמצעות פרוטוקולי RF433, Z-Wave, ZigBee, Bluetooth ו- WiFi נמצאים בשימוש נרחב. היתרונות העיקריים שלהם הם קלות ההתקנה והשימוש, כמו גם עלות נמוכה ואמינות, כי היצרנים שואפים להביא את המכשירים שלהם לשוק ההמוני ולהנגיש אותם למשתמש הממוצע.

חיישנים ומפעילים, ככלל, מחוברים באמצעות ממשק אלחוטי לבקר בית חכם (6) - מיקרו מחשב מיוחד המשלב את כל המכשירים הללו לרשת אחת ושולט בהם.

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

כדי לחבר את בקר הבית החכם לרשת העולמית, ניתן להשתמש בנתב אינטרנט רגיל (7), שהפך מזמן למכשיר ביתי נפוץ בכל בית. כאן יש טיעון נוסף לטובת בקר בית חכם - אם החיבור לאינטרנט אבד, הבית החכם ימשיך לפעול כרגיל הודות לבלוק הלוגי המאוחסן בתוך הבקר, ולא בשירות הענן.

בקר בית חכם

הבקר למערכת הבית החכם בענן הנדון במאמר זה פותח על בסיס מיקרו מחשב בעל לוח יחיד Raspberry Pi 3 דגם B+, אשר שוחרר במרץ 2018 ויש לו מספיק משאבים וביצועים עבור משימות בית חכם. הוא כולל מעבד ארבע ליבות Cortex-A53 המבוסס על ארכיטקטורת ARMv64-A של 8 סיביות, שעון במהירות 1.4 גיגה-הרץ, וכן 1 GB של זיכרון RAM, Wi-Fi 802.11ac, Bluetooth 4.2 ומתאם גיגה-ביט Ethernet הפועל באמצעות USB 2.0 .

הרכבת הבקר פשוטה מאוד - המיקרו מחשב (1) מותקן במארז פלסטיק (2), לאחר מכן מותקנים כרטיס זיכרון בנפח 8 GB בפורמט microSD עם תוכנה (3) ובקר רשת USB Z-Wave (4) החריצים המתאימים. בקר הבית החכם מחובר לאספקת החשמל באמצעות מתאם מתח 5V, 2.1A (5) וכבל USB - מיקרו USB (6). לכל בקר יש מספר זיהוי ייחודי, אשר כתוב בקובץ התצורה בעת ההשקה לראשונה והכרחי לאינטראקציה עם שירותי בית חכם בענן.

תוכנת בקר הבית החכם פותחה על ידי כותב מאמר זה על בסיס מערכת ההפעלה Linux Raspbian Stretch. הוא מורכב מתת המערכות העיקריות הבאות:

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

מסד נתונים בקר בית חכם מיושם על בסיס DBMS מוטבע SQLite והוא קובץ על כרטיס SD עם תוכנת מערכת. הוא משמש כאחסון עבור תצורת הבקר - מידע על הציוד המחובר ומצבו הנוכחי, בלוק של כללי ייצור לוגיים, כמו גם מידע הדורש אינדקס (לדוגמה, שמות קבצים של ארכיון וידאו מקומי). כאשר הבקר מופעל מחדש, המידע הזה נשמר, מה שמאפשר לשחזר את הבקר במקרה של הפסקת חשמל.

ממשק גרפי בקר בית חכם שפותח ב-PHP 7 באמצעות מיקרו-מסגרת רָזֶה. שרת האינטרנט אחראי להפעלת האפליקציה. lighttpd, משמש לעתים קרובות במכשירים משובצים בשל הביצועים הטובים ודרישות המשאבים הנמוכות שלו.

(לחץ על התמונה כדי לפתוח ברזולוציה גדולה יותר)

תפקידו העיקרי של הממשק הגרפי הוא חיבור ציוד בית חכם (מצלמות מעקב IP וחיישנים) לבקר. אפליקציית האינטרנט קוראת את התצורה והמצב הנוכחי של הבקר וההתקנים המחוברים אליו ממסד הנתונים של SQLite. כדי לשנות את תצורת הבקר, הוא שולח פקודות בקרה בפורמט JSON דרך ממשק RESTful API של תהליך השרת.

תהליך שרת

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

הבלוקים העיקריים של תהליך השרת הם:

1. מנהל הודעות;
2. שרת מצלמות IP;
3. שרת התקנים Z-Wave;
4. כללים לוגיים של שרת הייצור;
5. מסד נתונים של תצורה של הבקר ובלוק של כללים לוגיים;
6. שרת API RESTful לאינטראקציה עם הממשק הגרפי;
7. לקוח MQTT לאינטראקציה עם הענן.

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

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

סוג מכשיר
פרוטוקול
סוג הודעה
deviceState
הפקודה

חדר
onvif
sensorData
on
סטרימינג (הפעלה/כיבוי)

חיישן
zwave
הפקודה
כבוי
הקלטה (הפעלה/כיבוי)

אפקטור
mqtt
businessLogicRule
סטרימינג (הפעלה/כיבוי)
evice (הוסף/הסר)

businessLogic
ConfigurationData
הקלטה (הפעלה/כיבוי)

Bluetooth
deviceState
שגיאה

wifi

rf

לדוגמה, הודעה מגלאי תנועה של מצלמה נראית כך:

{
	"vendor": "*****",
	"version": "3.0.0",
	"timestampMs": "1566293475475",
	"clientType": "gateway",
	"deviceId": "1616453d-30cd-44b7-9bf0-************",
	"deviceType": "camera",
	"protocol": "onvif",
	"messageType": "sensorData",
	"sensorType": "camera",
	"label": "motionDetector",
	"sensorData": "on"
}

היגיון ייצור

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

{
	"if": {
	    "and": [{
		"equal": {
		    "deviceId": "1616453d-30cd-44b7-9bf0-************"
		}
	    },
	    {
		"equal": {
		    "messageType": "command"
		}
	    }
	    ]
	},
	"then": {
	    "result": "true"
	}
}

אם התנאים המפורטים ב קדם (צד שמאל) הכללים נכונים, אז זה מרוצה עוֹקֵב (צד ימין) כללים, והמטפל מקבל גישה לגוף הודעת ה-JSON. הקודמת תומכת באופרטורים לוגיים שמשווים צמדי מפתח-ערך של JSON:

1. שווה "שווה";
2. לא שווה ל"לא_שווה";
3. פחות "פחות";
4. יותר "גדול יותר";
5. פחות או שווה ל-"פחות_או_שווה";
6. גדול או שווה ל-"גדול_או_שווה".

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

1. ו ו"
2. או או";
3. לא לא".

לפיכך, על ידי כתיבת אופרטורים ואופרנדים בסימון פולני, ניתן ליצור תנאים מורכבים למדי עם מספר רב של פרמטרים.

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

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

מנגנון לוגיית הייצור שנדון לעיל מיושם באמצעות הספרייה RapidJSON - מנתח SAX עבור פורמט JSON ב-C++. קריאה וניתוח רציפים של מערך כללי ייצור מאפשרים לך ליישם בקלות את פונקציית השוואת הנתונים בתוך תקדימים:

void CRuleEngine::Process(PProperties pFact)
{
    m_pActions->clear();

    rapidjson::Reader   reader;
    for(TStringMap::value_type& rRule : m_Rules)
    {
        std::string sRuleId   = rRule.first;
        std::string sRuleBody = rRule.second;

        CRuleHandler            ruleHandler(pFact);
        rapidjson::StringStream ruleStream(sRuleBody.c_str());
        rapidjson::ParseResult  parseResult = reader.Parse(ruleStream, ruleHandler);
        if(!parseResult)
        {
            m_Logger.LogMessage(
                        NLogger2::ePriorityLevelError,
                        std::string("JSON parse error"),
                        "CRuleEngine::Process()",
                        std::string("RuleId: ") + sRuleId);
        }

        PProperties pAction = ruleHandler.GetAction();
        if(pAction)
        {
            pAction->Set("ruleId", sRuleId);
            m_pActions->push_back(pAction);
        }
    }
}

כאן pFact - מבנה המכיל צמדי מפתח-ערך מהודעת JSON, m_כללים - מערך מחרוזות של כללי ייצור. ההשוואה בין ההודעה הנכנסת לבין כלל ההפקה מתבצעת בפונקציה reader.Parse(ruleStream, ruleHandler)איפה ruleHandler הוא אובייקט המכיל את ההיגיון של אופרטורים בוליאניים והשוואה. sRuleId - מזהה כללים ייחודי, שבזכותו ניתן לאחסן ולערוך כללים בתוך מסד הנתונים של בקר הבית החכם. m_pActions - מערך עם תוצאות של הסקה לוגית: הודעות JSON המכילות השלכות מבסיס הכללים ונשלחות בהמשך למנהל ההודעות, כך שרשורי מנויים יוכלו לעבד אותן.

ביצועי RapidJSON דומים לפונקציה strlen (), ודרישות משאבי המערכת המינימליות מאפשרות שימוש בספרייה זו בהתקנים משובצים. השימוש בהודעות ובכללים לוגיים בפורמט JSON מאפשר ליישם מערכת גמישה של חילופי מידע בין כל רכיבי בקר הבית החכם.

חיישני גל Z-Wave ומפעילים

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

כעת ניתן למצוא בשוק מספר גדול למדי של מכשירי Z-Wave שונים. בואו נסתכל על כמה דוגמאות:

1. השקע החכם Zipato PAN16 יכול למדוד את הפרמטרים הבאים: צריכת חשמל (kWh), הספק (W), מתח (V) וזרם (A) ברשת החשמל. יש לו גם מתג מובנה שבעזרתו ניתן לשלוט במכשיר החשמלי המחובר;
2. חיישן הדליפה של Neo Coolcam מזהה נוכחות של נוזל שנשפך על ידי סגירת המגעים של הגשש המרוחק;
3. חיישן העשן Zipato PH-PSG01 מופעל כאשר חלקיקי עשן נכנסים לתא מנתח הגז;
4. חיישן התנועה Neo Coolcam מנתח את קרינת האינפרא אדום של גוף האדם. בנוסף יש חיישן אור (Lx);
5. Multisensor Philio PST02-A מודד טמפרטורה (°C), אור (%), פתיחת דלת, נוכחות של אדם בחדר;
6. Z-Wave USB Stick ZME E UZB1 בקר רשת שאליו מחוברים חיישנים.

חשוב מאוד שהמכשירים והבקר יפעלו באותו תדר, אחרת הם פשוט לא יראו אחד את השני ברגע החיבור. ניתן לחבר עד 232 מכשירים לבקר רשת Z-Wave אחד, וזה די מספיק עבור דירה או בית כפרי. כדי להרחיב את שטח כיסוי הרשת בתוך הבית, ניתן להשתמש בשקע חכם כמחזר אותות.

בתהליך שרת בקר הבית החכם שנדון בפסקה הקודמת, שרת Z-Wave אחראי על אינטראקציה עם התקני Z-Wave. הוא משתמש בספרייה כדי לקבל מידע מחיישנים OpenZWave ב-C++, המספק ממשק לאינטראקציה עם בקר ה-USB ברשת Z-Wave ועובד עם מגוון חיישנים ומפעילים. הערך של הפרמטר הסביבתי הנמדד על ידי החיישן נרשם על ידי שרת Z-Wave בצורה של הודעת JSON:

{
	"vendor": "*****",
	"version": "3.0.0",
	"timestampMs": "1566479791290",
	"clientType": "gateway",
	"deviceId": "20873eb0-dd5e-4213-a175-************",
	"deviceType": "sensor",
	"protocol": "zwave",
	"messageType": "sensorData",
	"homeId": "0xefa0cfa7",
	"nodeId": "20",
	"sensorType": "METER",
	"label": "Voltage",
	"sensorData": "229.3",
	"units": "V"
}

לאחר מכן הוא מועבר למנהל ההודעות של תהליך השרת, כך שרשורי מנויים יוכלו לקבל אותו. המנוי העיקרי הוא שרת ההיגיון של הייצור, התואם את ערכי שדות ההודעה בקדמותם של כללי ההיגיון. תוצאות ההסקה המכילות פקודות בקרה נשלחות חזרה למנהל ההודעות ומשם עוברות לשרת Z-Wave, שמפענח אותן ושולח אותן לבקר ה-USB ברשת Z-Wave. לאחר מכן הם נכנסים למפעיל, שמשנה את מצבם של חפצים סביבתיים, והבית החכם מבצע כך עבודה שימושית.

(לחץ על התמונה כדי לפתוח ברזולוציה גדולה יותר)

חיבור מכשירי Z-Wave נעשה בממשק הגרפי של בקר הבית החכם. כדי לעשות זאת, עבור לדף עם רשימת מכשירים ולחץ על כפתור "הוסף". פקודת ה-add דרך ממשק RESTful API נכנסת לתהליך השרת ולאחר מכן נשלחת על ידי מנהל ההודעות לשרת Z-Wave, מה שמכניס את בקר ה-USB ברשת Z-Wave למצב מיוחד להוספת התקנים. לאחר מכן, במכשיר ה-Z-Wave עליך לבצע סדרה של לחיצות מהירות (3 לחיצות תוך 1,5 שניות) על כפתור השירות. בקר ה-USB מחבר את המכשיר לרשת ושולח מידע אודותיו לשרת Z-Wave. זה, בתורו, יוצר ערך חדש במסד הנתונים של SQLite עם הפרמטרים של המכשיר החדש. לאחר מרווח זמן מוגדר, הממשק הגרפי חוזר לדף רשימת התקני Z-Wave, קורא מידע ממסד הנתונים ומציג את המכשיר החדש ברשימה. כל מכשיר מקבל מזהה ייחודי משלו, המשמש בחוקי מסקנות ייצור ובעבודה בענן. הפעולה של אלגוריתם זה מוצגת בתרשים UML:

(לחץ על התמונה כדי לפתוח ברזולוציה גדולה יותר)

חיבור מצלמות IP

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

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

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

הפרוטוקול הפופולרי ביותר עבור מערכות מעקב וידאו IP, הנתמך כעת על ידי כל יצרני מצלמות ה-IP ללא יוצא מן הכלל, הוא פרופיל ONVIF S, שהמפרט שלו קיים בשפת תיאור שירותי אינטרנט wsdl. שימוש בכלי עזר מתוך ערכת הכלים gSOAP אפשר ליצור קוד מקור עבור שירותים שעובדים עם מצלמות IP:

$ wsdl2h -o onvif.h 
	https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl 
	https://www.onvif.org/ver10/events/wsdl/event.wsdl 
	https://www.onvif.org/ver10/media/wsdl/media.wsdl 
	https://www.onvif.org/ver20/ptz/wsdl/ptz.wsdl

$ soapcpp2 -Cwvbj -c++11 -d cpp_files/onvif -i onvif.h

כתוצאה מכך, אנו מקבלים קבוצה של קבצי כותרת "*.h" ומקור "*.cpp" ב-C++, אותם ניתן למקם ישירות לתוך אפליקציה או ספריה נפרדת ולהרכיב באמצעות מהדר GCC. בשל הפונקציות הרבות, הקוד גדול ודורש אופטימיזציה נוספת. למיקרו-מחשב Raspberry Pi 3 דגם B+ יש ביצועים מספיקים לביצוע קוד זה, אך אם יש צורך להעביר את הקוד לפלטפורמה אחרת, יש צורך לבחור את ארכיטקטורת המעבד ואת משאבי המערכת הנכונים.

מצלמות IP התומכות בתקן ONVIF, כאשר פועלות ברשת מקומית, מחוברות לקבוצת ריבוי שידור מיוחדת עם הכתובת 239.255.255.250. יש פרוטוקול WS Discovery, המאפשר לך להפוך את החיפוש אחר מכשירים ברשת המקומית לאוטומטית.

הממשק הגרפי של בקר הבית החכם מיישם פונקציית חיפוש עבור מצלמות IP ב-PHP, הנוחה מאוד בעת אינטראקציה עם שירותי אינטרנט באמצעות הודעות XML. בעת בחירת פריטי תפריט התקנים > מצלמות IP > סריקה האלגוריתם לחיפוש מצלמות IP מופעל, ומציג את התוצאה בצורה של טבלה:

(לחץ על התמונה כדי לפתוח ברזולוציה גדולה יותר)

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

לאחר מכן, נוצרת הודעה בפורמט JSON המכילה את כל הפרמטרים של המצלמה שנוספה ונשלחת לתהליך השרת של בקר הבית החכם באמצעות פקודת RESTful API, כאשר פרמטרי המצלמה מפוענחים ונשמרים במסד הנתונים הפנימי של SQLite, והם משמש גם להפעלת שרשורי העיבוד הבאים:

1. יצירת חיבור RTSP לקבלת זרמי וידאו ואודיו;
2. המרת אודיו מפורמטים G.711 mu-Law, G.711 A-Law, G.723 וכו'. לפורמט AAC;
3. המרת זרמי וידאו בפורמט H.264 ואודיו בפורמט AAC לתוך מיכל FLV והעברתו לענן באמצעות פרוטוקול RTMP;
4. יצירת חיבור עם נקודת הקצה של גלאי התנועה של מצלמת ה-IP באמצעות פרוטוקול ONVIF ותשאול אותו מעת לעת;
5. יצירת מעת לעת תמונת תצוגה מקדימה של תמונה ממוזערת ושליחתה לענן באמצעות פרוטוקול MQTT;
6. הקלטה מקומית של זרמי וידאו ואודיו בצורה של קבצים נפרדים בפורמט MP4 על גבי כרטיס SD או Flash של בקר הבית החכם.

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

בניסוי בדיקת הביצועים, 3 מצלמות חוברו לבקר:

1. HiWatch DS-I114W (רזולוציה - 720p, פורמט דחיסה - H.264, קצב סיביות - 1 Mb/s, צליל G.711 mu-Law);
2. Microdigital MDC-M6290FTD-1 (רזולוציה - 1080p, פורמט דחיסה - H.264, קצב סיביות - 1 Mb/s, ללא צליל);
3. Dahua DH-IPC-HDW4231EMP-AS-0360B (רזולוציה - 1080p, פורמט דחיסה - H.264, קצב סיביות - 1.5 Mb/s, אודיו AAC).

כל שלושת הזרמים הופקו בו זמנית לענן, המרת קידוד אודיו בוצע ממצלמה אחת בלבד, והקלטת ארכיון מקומי הושבתה. עומס המעבד היה כ-5%, שימוש ב-RAM היה 32 מגה-בייט (לתהליך), 56 מגה-בייט (סה"כ כולל מערכת הפעלה).

כך, ניתן לחבר כ-20 - 30 מצלמות לבקר הבית החכם (בהתאם לרזולוציה וקצב סיביות), שמספיק למערכת מעקב וידאו לקוטג' בן שלוש קומות או למחסן קטן. עבור משימות הדורשות ביצועים טובים יותר, אתה יכול להשתמש ב-nettop עם מעבד אינטל מרובה ליבות ומערכת ההפעלה Linux Debian Sarge. הבקר נמצא כעת בהפעלת ניסיון, ונתוני הביצועים שלו יעודכנו.

אינטראקציה עם הענן

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

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

• QoS 0 - מקסימום פעם אחת (ללא הבטחת משלוח);
• QoS 1 - לפחות פעם אחת (עם אישור מסירה);
• QoS 2 - פעם אחת בדיוק (עם אישור משלוח נוסף).

במקרה שלנו, אנחנו משתמשים Eclipse Mosquito. שם הנושא הוא המזהה הייחודי של בקר הבית החכם. לקוח MQTT בתוך תהליך השרת נרשם לנושא זה ומתרגם אליו הודעות JSON המגיעות ממנהל ההודעות. לעומת זאת, הודעות מהמתווך של MQTT מועברות על ידו למנהל ההודעות, שלאחר מכן מרבה אותן למנויים שלו בתוך תהליך השרת:

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

לקוח MQTT פותח על בסיס יישום הספרייה Eclipse Paho בשפת C++.

זרמי מדיה של H.264 + AAC נשלחים לענן באמצעות פרוטוקול RTMP, כאשר אשכול שרתי מדיה אחראי על עיבודם ואחסוןם. כדי לפזר בצורה מיטבית את העומס באשכול ולבחור את שרת המדיה הכי פחות טעון, בקר הבית החכם מבצע בקשה מקדימה למאזן העומס בענן ורק לאחר מכן שולח את זרם המדיה.

מסקנה

המאמר בחן יישום ספציפי אחד של בקר בית חכם המבוסס על המיקרו-מחשב Raspberry Pi 3 B+, ​​שיכול לקבל, לעבד מידע ולשלוט בציוד באמצעות פרוטוקול Z-Wave, ליצור אינטראקציה עם מצלמות IP באמצעות פרוטוקול ONVIF, וגם להחליף נתונים ו פקודות עם שירות הענן באמצעות פרוטוקולי MQTT ו-RTMP. מנוע לוגיקת ייצור פותח על בסיס השוואה של כללים לוגיים ועובדות המוצגות בפורמט JSON.

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

הגרסה הבאה של הבקר מתכננת לחבר סוגים אחרים של מכשירים (RF, Bluetooth, WiFi, חוטי). לנוחות המשתמשים, הליך חיבור חיישנים ומצלמות IP יועבר לאפליקציית הנייד. יש גם רעיונות לאופטימיזציה של קוד תהליך השרת והעברת התוכנה למערכת ההפעלה OpenWRT. זה יאפשר לכם לחסוך בבקר נפרד ולהעביר את הפונקציונליות של בית חכם לנתב ביתי רגיל.

מקור: www.habr.com