A binding is a logical link between

A binding is a logical link between two devices at the application layer. Multiple bindings can be created
on a device, one for each type of data packet. In addition, a binding may have more than one destination
device ( one-to-many bindings ).
For example, in a lighting network with multiple switches and lights, each switch will control one or more
light. In that case, a binding should be created in each switch. This allows the application to send the data
packets without knowing the actual destination address.
Once a binding is created on the source device, the application can send data without specifying a
destination address (in the call to zb_SendDataRequest(), the invalid address - 0xFFFE should be used as
the destination ). This will cause the stack to look up the destination in its internal binding table based on
the command identifier of the packet.
There can be more than one destination in the binding entry. In that case, the stack will automatically send
a copy of the packet to each destination specified in the binding entry.
Also, if the NV_RESTORE compile option is enabled when building the image, the stack will save the
binding entries to non-volatile ram This is useful in the device has an accidental reset ( or if the batteries
need to be changed on the device ), the device can recover automatically without the user having to setup
the bindings again.
There are two mechanisms available to configure device bindings. If the extended address of the
destination device is known, the zb_BindDevice() can be to create a binding entry.
If the extended address is not known, a “push button” strategy may be employed. In this case, the
destination device is first put in a state where it will respond to match requests by issuing the
zb_AllowBindResponse(). Then the zb_ BindDevice() is issued on the source device with a null address.
In addition, bindings can be setup by using an external commissioning tool.
Note that bindings can only be created between “complementary” devices. That is, the binding will only
succeed if both devices have registered the same command_id in their simple descriptor structures and
one device has the command as an “output” while the other device has it as an “input”.

ผลลัพธ์ (ไทย) 2:

ผูกพันคือการเชื่อมโยงตรรกะระหว่างสองอุปกรณ์ที่ชั้นสมัคร ผูกหลายที่สามารถสร้างขึ้น
บนอุปกรณ์หนึ่งสำหรับแต่ละประเภทของการส่งข้อมูล นอกจากนี้ยังมีผลผูกพันอาจมีปลายทางมากกว่าหนึ่ง
อุปกรณ์ (One-to-หลายผูก).
ยกตัวอย่างเช่นในเครือข่ายแสงกับสวิทช์หลายและไฟสลับกันจะควบคุมหนึ่งหรือมากกว่า
แสง ในกรณีที่ผูกพันควรได้รับการสร้างขึ้นในแต่ละสวิทช์ นี้จะช่วยให้ประยุกต์ใช้ในการส่งข้อมูล
แพ็คเก็ตโดยไม่ทราบที่อยู่ปลายทางที่เกิดขึ้นจริง.
เมื่อผูกพันจะถูกสร้างขึ้นบนอุปกรณ์ของแหล่งที่มาของแอพลิเคชันสามารถส่งข้อมูลโดยไม่ได้ระบุ
ที่อยู่ปลายทาง (ในการเรียกร้องให้ zb_SendDataRequest () ที่อยู่ไม่ถูกต้อง - 0xFFFE ควรใช้เป็น
ปลายทาง) นี้จะทำให้สแต็คที่จะมองขึ้นปลายทางในตารางผูกพันภายในอยู่บนพื้นฐานของ
ตัวระบุคำสั่งของแพ็กเก็ต.
สามารถมีได้มากกว่าหนึ่งปลายทางในรายการที่มีผลผูกพัน ในกรณีที่สแต็คจะส่ง
สำเนาของแพ็คเก็ตให้กับแต่ละปลายทางที่ระบุไว้ในรายการผูกพัน.
นอกจากนี้ถ้า NV_RESTORE รวบรวมตัวเลือกที่ถูกเปิดใช้งานเมื่อมีการสร้างภาพสแต็คจะบันทึก
รายการที่มีผลผูกพันจะไม่ระเหย RAM นี้ จะเป็นประโยชน์ในอุปกรณ์ที่มีการตั้งค่าโดยไม่ตั้งใจ (หรือถ้าแบตเตอรี่
ต้องมีการเปลี่ยนแปลงบนอุปกรณ์) อุปกรณ์ที่สามารถกู้คืนโดยอัตโนมัติโดยที่ผู้ใช้ไม่ต้องติดตั้ง
วงกบประตูอีกครั้ง.
มีสองกลไกที่มีอยู่ในการกำหนดค่าอุปกรณ์การผูกอยู่ หากที่อยู่ขยายของ
อุปกรณ์ปลายทางที่เป็นที่รู้จักกันที่ zb_BindDevice () สามารถที่จะสร้างรายการที่มีผลผูกพัน.
หากที่อยู่ขยายไม่เป็นที่รู้จักเป็น "กดปุ่ม" กลยุทธ์การอาจจะต้องใช้ ในกรณีนี้
อุปกรณ์ปลายทางใส่ครั้งแรกในรัฐที่จะตอบสนองให้ตรงกับการร้องขอโดยการออกเป็น
zb_AllowBindResponse () แล้ว zb_ BindDevice () จะออกบนอุปกรณ์ที่มาพร้อมกับที่อยู่ null.
นอกจากนี้ผูกสามารถติดตั้งโดยใช้เครื่องมือการว่าจ้างภายนอก.
โปรดทราบว่าผูกเท่านั้นที่สามารถสร้างขึ้นระหว่างอุปกรณ์ "เสริม" นั่นคือผูกพันเท่านั้นที่จะ
ประสบความสำเร็จถ้าอุปกรณ์ทั้งสองได้จดทะเบียน command_id เดียวกันในโครงสร้างที่บ่งง่ายของพวกเขาและ
อุปกรณ์หนึ่งที่มีคำสั่งเป็น "ส่งออก" ในขณะที่อุปกรณ์อื่น ๆ ที่มีมันเป็น "ป้อนข้อมูล"

ผลลัพธ์ (ไทย) 3:

ผูกเป็นตรรกะเชื่อมโยงระหว่างสองอุปกรณ์ที่ชั้นสมัคร หลายชนิดสามารถสร้างขึ้นบนอุปกรณ์หนึ่งสำหรับแต่ละประเภทของแพ็กเก็ตข้อมูล นอกจากนี้ เซลล์อาจมีมากกว่าหนึ่งปลายทางอุปกรณ์ ( หลายชนิด )ตัวอย่างเช่น ในแสงเครือข่ายสวิทช์หลายและไฟแต่ละสวิตช์จะควบคุมหนึ่งหรือมากกว่าแสง ในกรณีที่ผูกควรถูกสร้างขึ้นในแต่ละสวิตช์ นี้จะช่วยให้โปรแกรมส่งข้อมูลแพ็คเก็ตโดยไม่ทราบปลายทางที่แท้จริงเมื่อเซลล์ถูกสร้างขึ้นบนแหล่งอุปกรณ์ โปรแกรมสามารถส่งข้อมูลโดยไม่ระบุปลายทาง ( ในการเรียก zb_senddatarequest() , ไม่ถูกต้องใน 0xfffe ควรใช้เป็นปลายทาง ) นี้จะทำให้กองเพื่อค้นหาปลายทางในตารางผูกพันภายในของตนตามคำสั่งระบุของแพ็คเก็ตสามารถมีได้มากกว่าหนึ่งปลายทางในการเข้าเล่ม ในกรณีที่กองโดยอัตโนมัติจะส่งสำเนาของแพ็กเก็ตแต่ละปลายทางที่ระบุไว้ในรายการผูกพันนอกจากนี้ ถ้า nv_restore รวบรวมตัวเลือก เปิดใช้งานเมื่อมีการสร้างภาพกองจะรักษารายการผูกพันที่จะไม่ระเหยรามนี้มีประโยชน์ในอุปกรณ์ที่มีการตั้งค่าโดยบังเอิญ ( หรือถ้าแบตเตอรี่ต้องเปลี่ยนบนเครื่อง ) , อุปกรณ์ที่สามารถกู้คืนโดยอัตโนมัติโดยที่ผู้ใช้ต้องติดตั้งผูกอีกมีสองกลไกที่มีอยู่เพื่อปรับแต่งการจับคู่อุปกรณ์ ถ้าขยายที่อยู่ของอุปกรณ์ปลายทางที่เป็นที่รู้จักกัน , zb_binddevice() สามารถสร้างรายการผูกพันถ้าขยายที่อยู่ไม่เป็นที่รู้จัก " ปุ่ม " ดันกลยุทธ์อาจจะใช้ ในกรณีนี้อุปกรณ์ปลายทางจะใส่ครั้งแรกในรัฐซึ่งจะตอบสนองให้ตรงกับความต้องการ โดยการออกzb_allowbindresponse() . แล้ว zb_ binddevice() ออกบนแหล่งอุปกรณ์ที่มีที่อยู่ใน .โดยรวมสามารถติดตั้งโดยใช้ภายนอกทดสอบเครื่องมือทราบว่าผูกสามารถสร้างระหว่าง " อุปกรณ์เสริม " นั่นคือ ผูกพันจะเท่านั้นประสบความสำเร็จถ้าอุปกรณ์ทั้งสองได้จดทะเบียน command_id เดียวกันในโครงสร้างหัวเรื่องง่ายและเครื่องหนึ่งมีคำสั่งเป็น " ผลผลิต " ในขณะที่อุปกรณ์อื่น ๆ มันเป็น " ข้อมูล "