วิธีใช้อนุภาค Bluetooth API อันทรงพลัง

โพสต์นี้มาจาก www.jaredwolff.com

ฉันพ่ายแพ้

ฉันใช้เวลาทั้งคืนเพื่อพยายามให้โปรเจ็กต์ Bluetooth Low Energy ทำงาน มันเจ็บปวด มันน่าผิดหวัง ฉันพร้อมที่จะยอมแพ้

นั่นคือช่วงแรก ๆ ของ Bluetooth Low Energy ตั้งแต่นั้นมา การพัฒนาก็ง่ายขึ้นและง่ายขึ้น ห้องสมุด Bluetooth Particle Mesh ก็ไม่มีข้อยกเว้น

ในคำแนะนำนี้ ฉันจะแสดงวิธีใช้ Bluetooth API ของ Particle เราจะกำหนดค่า LED บางดวงและดูการเปลี่ยนแปลงในอุปกรณ์ทั้งหมดในเครือข่าย Mesh เราจะใช้บอร์ด Argon และ Xenon

พร้อม? เริ่มกันเลย!

ป.ล. โพสต์นี้มีความยาว หากคุณต้องการดาวน์โหลดอะไร คลิกที่นี่สำหรับไฟล์ PDF ที่มีรูปแบบสวยงาม

ขั้นตอนที่ 1:การตั้งค่าบลูทูธ

ดาวน์โหลด/ติดตั้ง Particle Workbench
สร้างโครงการใหม่ ฉันเลือกตำแหน่งที่เหมาะสมแล้วตั้งชื่อว่า ble_mesh
ไปที่ /src/ . ของคุณ ไดเรกทอรีและเปิด <your project name>.ino . ของคุณ ไฟล์
จากนั้นตรวจสอบให้แน่ใจว่าคุณเปลี่ยนเวอร์ชันของระบบปฏิบัติการของอุปกรณ์เป็น> 1.3.0

เขียนโค้ด

เราต้องการจัดตั้งบริการที่มี 3 ลักษณะ ลักษณะนี้สัมพันธ์กับความเข้มของไฟ LED RGB ตามลำดับ วิธีตั้งค่าบลูทูธของคุณมีดังต่อไปนี้:

ใน Setup() . ของคุณ ฟังก์ชั่นเปิดใช้งานแอพควบคุม LED ของคุณ
```
RGB.control(true);
```
ตั้งค่า UUID ของคุณที่ด้านบนของ .ino ไฟล์
```
 const char* serviceUuid = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E";
 const char* red         = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E";
 const char* green       = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E";
 const char* blue        = "6E400004-B5A3-F393-E0A9-E50E24DCCA9E";
```
UUID เป็นตัวระบุหรือที่อยู่ที่ไม่ซ้ำกัน ใช้เพื่อแยกความแตกต่างของบริการและลักษณะเฉพาะในอุปกรณ์

UUID ข้างต้นใช้ในตัวอย่างอนุภาคก่อนหน้า หากคุณต้องการสร้างของคุณเอง คุณสามารถใช้ uuidgen บนบรรทัดคำสั่ง OSX คุณยังสามารถไปที่เว็บไซต์ เช่น เครื่องมือสร้าง GUID ออนไลน์

ใช้การตั้งค่าด้านบนเพื่อรับ UUID ของคุณเอง จากนั้น คุณสามารถสร้างบริการและ UUIDS ลักษณะเฉพาะของคุณได้จากบริการที่สร้างขึ้นนี้:
```
 const char* serviceUuid = "b425040**0**-fb4b-4746-b2b0-93f0e61122c6"; //service
 const char* red         = "b4250401-fb4b-4746-b2b0-93f0e61122c6"; //red char
 const char* green       = "b4250402-fb4b-4746-b2b0-93f0e61122c6"; //green char
 const char* blue        = "b4250403-fb4b-4746-b2b0-93f0e61122c6"; //blue char
```
ไม่มีทางถูกหรือผิดในการทำเช่นนี้ แต่คุณต้องระวังว่าคุณไม่ได้ใช้ UUID ที่สงวนไว้โดย Bluetooth SIG ไม่น่าจะเป็นไปได้สูง หากคุณต้องการตรวจสอบอีกครั้ง คุณสามารถไปที่นี่และที่นี่

สำหรับตอนนี้ เราจะใช้ UUID ชุดแรก
ใน Setup() , เริ่มต้นบริการของคุณ
```
 // Set the RGB BLE service
 BleUuid rgbService(serviceUuid);
```
นี่เป็นขั้นตอนแรกของ "การลงทะเบียน" บริการของคุณ ดูข้อมูลเพิ่มเติมด้านล่าง
เริ่มต้นแต่ละคุณลักษณะใน Setup()
```
 BleCharacteristic redCharacteristic("red", BleCharacteristicProperty::WRITE_WO_RSP, red, serviceUuid, onDataReceived, (void*)red);
 BleCharacteristic greenCharacteristic("green", BleCharacteristicProperty::WRITE_WO_RSP, green, serviceUuid, onDataReceived, (void*)green);
 BleCharacteristic blueCharacteristic("blue", BleCharacteristicProperty::WRITE_WO_RSP, blue, serviceUuid, onDataReceived, (void*)blue);
```
สำหรับการตั้งค่านี้ เราจะใช้ WRITE_WO_RSP คุณสมบัติ. ซึ่งช่วยให้เราสามารถเขียนข้อมูลและคาดว่าจะไม่มีการตอบกลับ
ฉันได้อ้างอิง UUID เป็นพารามิเตอร์สองตัวถัดไป ประการแรกคือลักษณะ UUID ประการที่สองคือบริการ UUID

พารามิเตอร์ถัดไปคือฟังก์ชันเรียกกลับ เมื่อข้อมูลถูกเขียนลงในคอลแบ็กนี้ ฟังก์ชันนี้จะเริ่มทำงาน

ในที่สุดพารามิเตอร์สุดท้ายคือบริบท สิ่งนี้หมายความว่าอย่างไร? เราใช้การเรียกกลับแบบเดียวกันสำหรับคุณลักษณะทั้งสามนี้ วิธีเดียวที่เราจะทราบได้ว่าคุณลักษณะใดเขียนถึง (อย่างน้อยใน deviceOS) คือการตั้งค่าบริบท ในกรณีนี้ เราจะใช้ UUID ที่มีอยู่แล้ว

หลังจากกำหนดลักษณะแล้ว ให้เพิ่มเพื่อให้แสดง:

 // Add the characteristics
 BLE.addCharacteristic(redCharacteristic);
 BLE.addCharacteristic(greenCharacteristic);
 BLE.addCharacteristic(blueCharacteristic);

ตั้งค่าฟังก์ชันการโทรกลับ
```
 // Static function for handling Bluetooth Low Energy callbacks
 static void onDataReceived(const uint8_t* data, size_t len, const BlePeerDevice& peer, void* context) {

 }
```
คุณสามารถทำได้ที่ด้านบนของไฟล์ (เหนือ Setup() ) เราจะอธิบายเพิ่มเติมในภายหลัง
สุดท้ายนี้ เพื่อให้อุปกรณ์ของคุณเชื่อมต่อได้ เราต้องตั้งค่าโฆษณา วางโค้ดนี้ไว้ท้าย Setup() . ของคุณ ฟังก์ชัน
```
 // Advertising data
 BleAdvertisingData advData;

 // Add the RGB LED service
 advData.appendServiceUUID(rgbService);

 // Start advertising!
 BLE.advertise(&advData);
```
ขั้นแรก เราสร้าง BleAdvertisingData วัตถุ. เราเพิ่ม rgbService จากขั้นตอนที่ 3 สุดท้ายนี้ เราสามารถเริ่มโฆษณาเพื่อให้ค้นพบบริการและคุณลักษณะของเราได้!

ถึงเวลาทดสอบ

ณ จุดนี้เรามีโปรแกรมที่ทำงานได้น้อยที่สุด มาคอมไพล์และตั้งโปรแกรมให้กับฮาร์ดแวร์อนุภาคของเรา สิ่งนี้ควรใช้งานได้กับอุปกรณ์ที่เปิดใช้งาน Mesh (ซีนอน อาร์กอน โบรอน)

ก่อนที่เราจะเริ่มการทดสอบ ให้เพิ่ม SYSTEM_MODE(MANUAL); . ชั่วคราว ที่ด้านบนสุดของไฟล์ของคุณ ซึ่งจะป้องกันไม่ให้อุปกรณ์เชื่อมต่อกับเครือข่ายแบบเมช หากอุปกรณ์กะพริบเป็นสีน้ำเงินเมื่อเริ่มต้นระบบ คุณจะต้องตั้งค่าด้วยแอปอนุภาคก่อนดำเนินการต่อ
ดาวน์โหลดอิมเมจ 1.3.0-rc.1 ที่นี่ สำหรับ Xenon คุณจะต้องมี [email protected] สำหรับคนอื่นๆ ให้มองหา [email protected] และ [email protected]. ไฟล์อยู่ที่ด้านล่างของหน้าภายใต้ เนื้อหา
ทำให้อุปกรณ์ของคุณเข้าสู่โหมด DFU กดปุ่ม โหมด . ค้างไว้ และคลิก รีเซ็ต . สักครู่ ปุ่ม ถือ ปุ่มโหมด . ค้างไว้ต่อไป จนกว่าไฟ LED จะกะพริบเป็นสีเหลือง
ในหน้าต่างบรรทัดคำสั่ง เปลี่ยนไดเร็กทอรีไปยังตำแหน่งที่คุณจัดเก็บไฟล์ที่คุณดาวน์โหลด ในกรณีของฉัน คำสั่งคือ cd ~/Downloads/
จากนั้นเรียกใช้:
```
 particle flash --usb [email protected]
```
การดำเนินการนี้จะติดตั้งระบบปฏิบัติการล่าสุดให้กับ Xenon ของคุณ เมื่อเสร็จแล้วจะกะพริบเป็นสีเหลืองอย่างรวดเร็วต่อไป อีกครั้ง หากคุณมีอุปกรณ์ Particle Mesh อื่น ให้เปลี่ยนชื่อไฟล์ให้ตรงกัน
ใน Visual Code ให้ใช้ Command + Shift + P คีย์ผสมเพื่อเปิดเมนูคำสั่ง เลือก Particle:Compile application (ในเครื่อง)
แก้ไขข้อผิดพลาดที่อาจปรากฏขึ้น
จากนั้น เปิดเมนูเดิมและเลือก แอปพลิเคชัน Flash (ในเครื่อง)
เมื่อตั้งโปรแกรมเสร็จแล้ว ให้ดึงโทรศัพท์ของคุณออกมา จากนั้นเปิดแอป Bluetooth Low Energy ที่คุณชื่นชอบ สิ่งที่ดีที่สุดคือ NRF Connect และ Light Blue Explorer ฉันจะใช้ Light Blue Explorer สำหรับตัวอย่างนี้
ตรวจสอบว่าอุปกรณ์ชื่อ "Xenon-" คือการโฆษณา แทรก ด้วย ID เฉพาะสำหรับอุปกรณ์ของคุณ
ค้นหาอุปกรณ์ของคุณแล้วคลิกชื่อ
ดูรายการบริการและลักษณะ รวมบริการและคุณลักษณะของ UUID ที่เราตั้งไว้หรือไม่? ตัวอย่างเช่น บริการ UUID แสดงเป็น 6E400001-B5A3-F393-E0A9-E50E24DCCA9E หรือไม่ ?

หากทุกอย่างเป็นไปตามที่คุณคาดหวัง แสดงว่าคุณอยู่ในที่ที่ดี หากไม่ปฏิบัติตามคำแนะนำก่อนหน้านี้เพื่อให้แน่ใจว่าทุกอย่างตรงกัน

ขั้นตอนที่ 2:การจัดการข้อมูล

ขั้นตอนต่อไปของโครงการของเราคือการประมวลผลกิจกรรมการเขียน เราจะอัปเดต onDataReceived . ของเรา ฟังก์ชัน

เขียนโค้ด

ขั้นแรก ให้สร้างโครงสร้างที่จะรักษาสถานะของ LED สามารถทำได้ที่ด้านบนของไฟล์
```
 // Variables for keeping state
 typedef struct {
   uint8_t red;
   uint8_t green;
   uint8_t blue;
 } led_level_t;
```
ครึ่งหลังคือการสร้างตัวแปรสแตติกโดยใช้ข้อมูลประเภทนี้
```
 // Static level tracking
 static led_level_t m_led_level;
```
สองขั้นตอนแรกช่วยให้เราใช้ตัวแปรเดียวเพื่อแสดงค่าสามค่าของ RGB LED
ต่อไป มาตรวจสอบข้อผิดพลาดพื้นฐานใน onDataReceive ฟังก์ชัน เช่น เราต้องการให้แน่ใจว่าเราได้รับเพียงหนึ่งไบต์เท่านั้น
```
 // We're only looking for one byte
   if( len != 1 ) {
     return;
 	}
```
ต่อไปเราต้องการที่จะดูว่าเหตุการณ์นี้มาจากลักษณะใด เราสามารถใช้ context เพื่อกำหนดตัวแปรนี้
```
 // Sets the global level
   if( context == red ) {
     m_led_level.red = data[0];
   } else if ( context == green ) {
     m_led_level.green = data[0];
   } else if ( context == blue ) {
     m_led_level.blue = data[0];
   }
```
โปรดจำไว้ว่า ในกรณีนี้ บริบทจะเท่ากับตัวชี้ของสตริง UUID สีแดง สีเขียว หรือสีน้ำเงิน นอกจากนี้ คุณยังสังเกตเห็นว่าเรากำลังตั้งค่า m_led_level . ด้วยวิธีนี้ เราสามารถอัปเดต RGB led ได้ แม้ว่าจะมีการเปลี่ยนแปลงเพียงค่าเดียว
สุดท้ายเมื่อตั้งค่าแล้ว คุณสามารถเขียนไปที่ RGB วัตถุ
```
 // Set RGB color
 	RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);
```

ทดสอบโค้ด

มาทำตามขั้นตอนเดิมกันก่อนเพื่อแฟลชเครื่อง

ทำให้อุปกรณ์ของคุณเข้าสู่โหมด DFU กดปุ่ม โหมด . ค้างไว้ และคลิกปุ่ม รีเซ็ต ปุ่ม ถือ ปุ่มโหมด . ค้างไว้ต่อไป จนกว่าไฟ LED จะกะพริบเป็นสีเหลือง
จากนั้น เปิดเมนูเดิมและเลือก แอปพลิเคชัน Flash (ในเครื่อง)
เมื่อเขียนโปรแกรมเสร็จแล้ว ให้เชื่อมต่อกับอุปกรณ์โดยใช้ Light Blue Explorer .
แตะที่คุณสมบัติที่ใช้กับไฟ LED สีแดง
เขียน FF . ไฟ LED สีแดงควรสว่างขึ้น
เขียน 00 . ไฟ LED สีแดงควรดับลง
ทำเช่นเดียวกันกับอีกสองลักษณะ ตอนนี้เราควบคุม RGB LED ได้อย่างเต็มที่ผ่าน Bluetooth Low Energy!

ระยะที่ 3:การแชร์ผ่าน Mesh

สุดท้ายนี้ เมื่อเราได้รับข้อความ BLE เรียบร้อยแล้ว ก็ถึงเวลาส่งต่อไปยังเครือข่ายตาข่ายของเรา

เขียนโค้ด

ขั้นแรกให้ลบโหมด MANUAL แสดงความคิดเห็น SYSTEM_MODE(MANUAL);
ที่ด้านบนของไฟล์ ให้เพิ่มตัวแปรที่เราจะใช้ในการติดตามว่าเราจำเป็นต้องเผยแพร่หรือไม่
```
 // Tracks when to publish to Mesh
 static bool m_publish;
```
จากนั้นเริ่มต้นใน Setup()
```
 // Set to false at first
 m_publish = false;
```
จากนั้นหลังจากตั้งค่า RGB led ใน onDataReceived โทรกลับ ให้มันจริง:
```
 // Set RGB color
 RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);

 // Set to publish
 m_publish = true;
```
มาเพิ่มเงื่อนไขใน loop() การทำงาน. ซึ่งจะทำให้เราเผยแพร่สถานะ LED ไปยังเครือข่าย Mesh:
```
 if( m_publish ) {
 	// Reset flag
 	m_publish = false;

 	// Publish to Mesh
   Mesh.publish("red", String::format("%d", m_led_level.red));
   Mesh.publish("green", String::format("%d", m_led_level.green));
   Mesh.publish("blue", String::format("%d", m_led_level.blue));
 }
```
Mesh.publish ต้องการสตริงสำหรับอินพุตทั้งสอง ดังนั้นเราจึงใช้ String::format เพื่อสร้างสตริงที่มีค่าสีแดง สีเขียว และสีน้ำเงิน
จากนั้นมาสมัครตัวแปรเดียวกันใน Setup() . วิธีนี้จะทำให้อุปกรณ์อื่นทำให้ LED บนอุปกรณ์นี้อัปเดตได้เช่นกัน
```
 Mesh.subscribe("red", meshHandler);
 Mesh.subscribe("green", meshHandler);
 Mesh.subscribe("blue", meshHandler);
```
ไปที่ด้านบนของไฟล์เราต้องการสร้าง meshHandler
```
 // Mesh event handler
 static void meshHandler(const char *event, const char *data)
 {
 }
```
ในแอปพลิเคชันนี้ เราต้องการ event พารามิเตอร์และ data พารามิเตอร์. ในการใช้งาน เราต้องเปลี่ยนเป็น String พิมพ์. ด้วยวิธีนี้ เราจึงสามารถใช้ฟังก์ชันการแปลงและการเปรียบเทียบในตัวได้ ดังนั้น ภายใน meshHandler เพิ่มฟังก์ชัน:
```
   // Convert to String for useful conversion and comparison functions
   String eventString = String(event);
   String dataString = String(data);
```
ในที่สุดเราก็ทำการเปรียบเทียบ ก่อนอื่นเราตรวจสอบว่าชื่อเหตุการณ์ตรงกันหรือไม่ จากนั้นเราก็ตั้งค่า dataString ไปยังระดับนำที่สอดคล้องกัน
```
   // Determine which event we recieved
   if( eventString.equals("red") ) {
     m_led_level.red = dataString.toInt();
   } else if ( eventString.equals("green") ) {
     m_led_level.green = dataString.toInt();
   } else if ( eventString.equals("blue") ) {
     m_led_level.blue = dataString.toInt();
   } else {
 		return;
 	}

   // Set RGB color
   RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);
```
ในตอนท้ายเราตั้งค่าสี RGB ใหม่ สังเกตว่าฉันจัดการกับสถานะที่ไม่รู้จักได้อย่างไรโดยเพิ่ม return คำสั่งใน else ส่วน. เป็นการดีเสมอที่จะกรองเงื่อนไขข้อผิดพลาดก่อนที่จะสร้างความเสียหาย!

ทดสอบโค้ด

เปิดแอปอนุภาคในโทรศัพท์ของคุณ
มาตั้งค่าอาร์กอนกันก่อน หากไม่กะพริบเป็นสีน้ำเงิน ให้กดปุ่มโหมดค้างไว้จนกว่าจะกะพริบเป็นสีน้ำเงิน

หมายเหตุ:หากคุณได้ตั้งโปรแกรมแอปไว้แล้ว ไฟ LED จะดับตามค่าเริ่มต้น กดปุ่มโหมดค้างไว้ 5 วินาทีแล้วดำเนินการต่อ
เข้าสู่กระบวนการจับคู่ แอพจะแนะนำคุณทุกขั้นตอน อย่าลืมจำรหัสผ่านผู้ดูแลระบบสำหรับเครือข่ายเมชของคุณ
ตั้งโปรแกรม Argon ด้วยเฟิร์มแวร์ล่าสุด (1.3.0) (ดู ขั้นตอนที่ 1 - เวลาทดสอบ - ขั้นตอนที่ 2 เพื่อเป็นเครื่องเตือนใจว่าต้องทำอย่างไร)
เมื่อกะพริบเป็นสีเหลืองอย่างรวดเร็ว ให้ตั้งโปรแกรม Argon ด้วยแอป Tinker สามารถดาวน์โหลดได้ที่หน้าเผยแพร่
เมื่อเรามีไฟ LED สีฟ้าที่เป็นของแข็ง (เชื่อมต่อกับ Particle Cloud) เราจะตั้งโปรแกรมแอป ใช้ Cloud Flash ในเมนูแบบเลื่อนลง

เท่าที่ฉันสามารถบอกได้ Particle บังคับให้อุปกรณ์ใด ๆ ที่แฟลชในเครื่องเข้าสู่เซฟโหมดเมื่อเชื่อมต่อกับคลาวด์ อาจเป็นการตั้งค่าของฉัน ไมล์สะสมของคุณอาจแตกต่างกันที่นี่ ควรใช้ Cloud Flash .

ตรวจสอบว่าคุณเลือกเวอร์ชันของอุปกรณ์ OS ที่ถูกต้อง (1.3.0-rc1 ) ประเภทอุปกรณ์ (อาร์กอน ) และชื่ออุปกรณ์ (สิ่งที่คุณตั้งชื่อระหว่างการตั้งค่า )
เชื่อมต่อกับซีนอนโดยใช้แอปโทรศัพท์
เชื่อมต่อ Xenon กับเครือข่าย Mesh ของคุณโดยใช้แอปโทรศัพท์
แฟลช Xenon ของคุณโดยใช้ Cloud Flash . ใช้ชื่อที่คุณตั้งไว้ระหว่างการตั้งค่าแอพโทรศัพท์ ตราบใดที่อุปกรณ์เชื่อมต่อกับ Particle Cloud หรืออยู่ในเซฟโหมด (Purple LED) ก็ควรตั้งโปรแกรม
เมื่อเชื่อมต่อแล้ว มาที่ส่วนที่สนุกกัน เปิด Light Blue Explorer เชื่อมต่อกับ อาร์กอน หรือ ซีนอน .
เลือกคุณสมบัติ LED อย่างใดอย่างหนึ่งและเปลี่ยนค่า

LED ควรเปลี่ยนในทุกอุปกรณ์!

รหัสสุดท้าย

นี่คือรหัสสุดท้ายที่มีชิ้นส่วนทั้งหมดรวมกัน คุณสามารถใช้สิ่งนี้เพื่อให้แน่ใจว่าคุณวางไว้ในที่ที่ถูกต้อง !!

/*
 * Project ble_mesh
 * Description: Bluetooth Low Energy + Mesh Example
 * Author: Jared Wolff
 * Date: 7/13/2019
 */

//SYSTEM_MODE(MANUAL);

// UUIDs for service + characteristics
const char* serviceUuid = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E";
const char* red         = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E";
const char* green       = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E";
const char* blue        = "6E400004-B5A3-F393-E0A9-E50E24DCCA9E";

// Set the RGB BLE service
BleUuid rgbService(serviceUuid);

// Variables for keeping state
typedef struct {
  uint8_t red;
  uint8_t green;
  uint8_t blue;
} led_level_t;

// Static level tracking
static led_level_t m_led_level;

// Tracks when to publish to Mesh
static bool m_publish;

// Mesh event handler
static void meshHandler(const char *event, const char *data)
{

  // Convert to String for useful conversion and comparison functions
  String eventString = String(event);
  String dataString = String(data);

  // Determine which event we recieved
  if( eventString.equals("red") ) {
    m_led_level.red = dataString.toInt();
  } else if ( eventString.equals("green") ) {
    m_led_level.green = dataString.toInt();
  } else if ( eventString.equals("blue") ) {
    m_led_level.blue = dataString.toInt();
  } else {
		return;
	}

  // Set RGB color
  RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);

}

// Static function for handling Bluetooth Low Energy callbacks
static void onDataReceived(const uint8_t* data, size_t len, const BlePeerDevice& peer, void* context) {

  // We're only looking for one byte
  if( len != 1 ) {
    return;
  }

  // Sets the global level
  if( context == red ) {
    m_led_level.red = data[0];
  } else if ( context == green ) {
    m_led_level.green = data[0];
  } else if ( context == blue ) {
    m_led_level.blue = data[0];
  }

  // Set RGB color
  RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);

  // Set to publish
  m_publish = true;

}

// setup() runs once, when the device is first turned on.
void setup() {

  // Enable app control of LED
  RGB.control(true);

  // Init default level
  m_led_level.red = 0;
  m_led_level.green = 0;
  m_led_level.blue = 0;

  // Set to false at first
  m_publish = false;

  // Set the subscription for Mesh updates
  Mesh.subscribe("red",meshHandler);
  Mesh.subscribe("green",meshHandler);
  Mesh.subscribe("blue",meshHandler);

  // Set up characteristics
  BleCharacteristic redCharacteristic("red", BleCharacteristicProperty::WRITE_WO_RSP, red, serviceUuid, onDataReceived, (void*)red);
  BleCharacteristic greenCharacteristic("green", BleCharacteristicProperty::WRITE_WO_RSP, green, serviceUuid, onDataReceived, (void*)green);
  BleCharacteristic blueCharacteristic("blue", BleCharacteristicProperty::WRITE_WO_RSP, blue, serviceUuid, onDataReceived, (void*)blue);

  // Add the characteristics
  BLE.addCharacteristic(redCharacteristic);
  BLE.addCharacteristic(greenCharacteristic);
  BLE.addCharacteristic(blueCharacteristic);

  // Advertising data
  BleAdvertisingData advData;

  // Add the RGB LED service
  advData.appendServiceUUID(rgbService);

  // Start advertising!
  BLE.advertise(&advData);
}

// loop() runs over and over again, as quickly as it can execute.
void loop() {

  // Checks the publish flag,
  // Publishes to a variable called "red" "green" and "blue"
  if( m_publish ) {

    // Reset flag
    m_publish = false;

    // Publish to Mesh
    Mesh.publish("red", String::format("%d", m_led_level.red));
    Mesh.publish("green", String::format("%d", m_led_level.green));
    Mesh.publish("blue", String::format("%d", m_led_level.blue));
  }

}

บทสรุป

ในบทช่วยสอนนี้ คุณได้เรียนรู้วิธีเพิ่ม Bluetooth ให้กับโปรเจ็กต์ Particle Mesh อย่างที่คุณจินตนาการได้ ความเป็นไปได้ไม่มีที่สิ้นสุด ตัวอย่างเช่น คุณสามารถเพิ่มผู้ใช้/แอปการดูแลระบบในประสบการณ์ได้ ตอนนี้สุดยอดมาก ?

คุณสามารถคาดหวังเนื้อหาเช่นนี้ในหนังสือเล่มต่อไปของฉัน:The Ultimate Guide to Particle Mesh . สมัครสมาชิกรายการของฉันสำหรับการอัปเดตและเนื้อหาภายใน นอกจากนี้ สมาชิกรุ่นแรกๆ ทุกคนจะได้รับส่วนลดเมื่อเปิดตัว! คลิกที่นี่เพื่อสมัคร