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

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

ฉันพ่ายแพ้

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

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

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

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

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

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

1. ดาวน์โหลด/ติดตั้ง Particle Workbench

2. สร้างโครงการใหม่ ฉันเลือกตำแหน่งที่เหมาะสมแล้วตั้งชื่อว่า ble_mesh

   

3. ไปที่ /src/ . ของคุณ ไดเรกทอรีและเปิด <your project name>.ino . ของคุณ ไฟล์

4. จากนั้นตรวจสอบให้แน่ใจว่าคุณเปลี่ยนเวอร์ชันของระบบปฏิบัติการของอุปกรณ์เป็น> 1.3.0

   

เขียนโค้ด

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

1. ใน Setup() . ของคุณ ฟังก์ชั่นเปิดใช้งานแอพควบคุม LED ของคุณ

   RGB.control(true);
   

2. ตั้งค่า 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 ชุดแรก

3. ใน Setup() , เริ่มต้นบริการของคุณ

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

   นี่เป็นขั้นตอนแรกของ "การลงทะเบียน" บริการของคุณ ดูข้อมูลเพิ่มเติมด้านล่าง

4. เริ่มต้นแต่ละคุณลักษณะใน 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 ที่มีอยู่แล้ว

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

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

6. ตั้งค่าฟังก์ชันการโทรกลับ

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

   คุณสามารถทำได้ที่ด้านบนของไฟล์ (เหนือ Setup() ) เราจะอธิบายเพิ่มเติมในภายหลัง

7. สุดท้ายนี้ เพื่อให้อุปกรณ์ของคุณเชื่อมต่อได้ เราต้องตั้งค่าโฆษณา วางโค้ดนี้ไว้ท้าย Setup() . ของคุณ ฟังก์ชัน

    // Advertising data
    BleAdvertisingData advData;
   
    // Add the RGB LED service
    advData.appendServiceUUID(rgbService);
   
    // Start advertising!
    BLE.advertise(&advData);
   

   ขั้นแรก เราสร้าง BleAdvertisingData วัตถุ. เราเพิ่ม rgbService จากขั้นตอนที่ 3 สุดท้ายนี้ เราสามารถเริ่มโฆษณาเพื่อให้ค้นพบบริการและคุณลักษณะของเราได้!

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

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

1. ก่อนที่เราจะเริ่มการทดสอบ ให้เพิ่ม SYSTEM_MODE(MANUAL); . ชั่วคราว ที่ด้านบนสุดของไฟล์ของคุณ ซึ่งจะป้องกันไม่ให้อุปกรณ์เชื่อมต่อกับเครือข่ายแบบเมช หากอุปกรณ์กะพริบเป็นสีน้ำเงินเมื่อเริ่มต้นระบบ คุณจะต้องตั้งค่าด้วยแอปอนุภาคก่อนดำเนินการต่อ

2. ดาวน์โหลดอิมเมจ 1.3.0-rc.1 ที่นี่ สำหรับ Xenon คุณจะต้องมี xenon-system-part1@1.3.0-rc.1.bin สำหรับคนอื่นๆ ให้มองหา boron-system-part1@1.3.0-rc.1.bin และ argon-system-part1@1.3.0-rc.1.bin. ไฟล์อยู่ที่ด้านล่างของหน้าภายใต้ เนื้อหา

   

3. ทำให้อุปกรณ์ของคุณเข้าสู่โหมด DFU กดปุ่ม โหมด . ค้างไว้ และคลิก รีเซ็ต . สักครู่ ปุ่ม ถือ ปุ่มโหมด . ค้างไว้ต่อไป จนกว่าไฟ LED จะกะพริบเป็นสีเหลือง

4. ในหน้าต่างบรรทัดคำสั่ง เปลี่ยนไดเร็กทอรีไปยังตำแหน่งที่คุณจัดเก็บไฟล์ที่คุณดาวน์โหลด ในกรณีของฉัน คำสั่งคือ cd ~/Downloads/

5. จากนั้นเรียกใช้:

    particle flash --usb xenon-system-part1@1.3.0-rc.1.bin
   

   การดำเนินการนี้จะติดตั้งระบบปฏิบัติการล่าสุดให้กับ Xenon ของคุณ เมื่อเสร็จแล้วจะกะพริบเป็นสีเหลืองอย่างรวดเร็วต่อไป อีกครั้ง หากคุณมีอุปกรณ์ Particle Mesh อื่น ให้เปลี่ยนชื่อไฟล์ให้ตรงกัน

6. ใน Visual Code ให้ใช้ Command + Shift + P คีย์ผสมเพื่อเปิดเมนูคำสั่ง เลือก Particle:Compile application (ในเครื่อง)

   

7. แก้ไขข้อผิดพลาดที่อาจปรากฏขึ้น

8. จากนั้น เปิดเมนูเดิมและเลือก แอปพลิเคชัน Flash (ในเครื่อง)

   

9. เมื่อตั้งโปรแกรมเสร็จแล้ว ให้ดึงโทรศัพท์ของคุณออกมา จากนั้นเปิดแอป Bluetooth Low Energy ที่คุณชื่นชอบ สิ่งที่ดีที่สุดคือ NRF Connect และ Light Blue Explorer ฉันจะใช้ Light Blue Explorer สำหรับตัวอย่างนี้

10. ตรวจสอบว่าอุปกรณ์ชื่อ "Xenon-" คือการโฆษณา แทรก ด้วย ID เฉพาะสำหรับอุปกรณ์ของคุณ

    

11. ค้นหาอุปกรณ์ของคุณแล้วคลิกชื่อ

12. ดูรายการบริการและลักษณะ รวมบริการและคุณลักษณะของ UUID ที่เราตั้งไว้หรือไม่? ตัวอย่างเช่น บริการ UUID แสดงเป็น 6E400001-B5A3-F393-E0A9-E50E24DCCA9E หรือไม่ ?

    

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

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

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

เขียนโค้ด

1. ขั้นแรก ให้สร้างโครงสร้างที่จะรักษาสถานะของ LED สามารถทำได้ที่ด้านบนของไฟล์

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

2. ครึ่งหลังคือการสร้างตัวแปรสแตติกโดยใช้ข้อมูลประเภทนี้

    // Static level tracking
    static led_level_t m_led_level;
   

   สองขั้นตอนแรกช่วยให้เราใช้ตัวแปรเดียวเพื่อแสดงค่าสามค่าของ RGB LED

3. ต่อไป มาตรวจสอบข้อผิดพลาดพื้นฐานใน onDataReceive ฟังก์ชัน เช่น เราต้องการให้แน่ใจว่าเราได้รับเพียงหนึ่งไบต์เท่านั้น

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

4. ต่อไปเราต้องการที่จะดูว่าเหตุการณ์นี้มาจากลักษณะใด เราสามารถใช้ 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 ได้ แม้ว่าจะมีการเปลี่ยนแปลงเพียงค่าเดียว

5. สุดท้ายเมื่อตั้งค่าแล้ว คุณสามารถเขียนไปที่ RGB วัตถุ

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

ทดสอบโค้ด

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

1. ทำให้อุปกรณ์ของคุณเข้าสู่โหมด DFU กดปุ่ม โหมด . ค้างไว้ และคลิกปุ่ม รีเซ็ต ปุ่ม ถือ ปุ่มโหมด . ค้างไว้ต่อไป จนกว่าไฟ LED จะกะพริบเป็นสีเหลือง

2. จากนั้น เปิดเมนูเดิมและเลือก แอปพลิเคชัน Flash (ในเครื่อง)

   

3. เมื่อเขียนโปรแกรมเสร็จแล้ว ให้เชื่อมต่อกับอุปกรณ์โดยใช้ Light Blue Explorer .

4. แตะที่คุณสมบัติที่ใช้กับไฟ LED สีแดง

5. เขียน FF . ไฟ LED สีแดงควรสว่างขึ้น

   

   

6. เขียน 00 . ไฟ LED สีแดงควรดับลง

7. ทำเช่นเดียวกันกับอีกสองลักษณะ ตอนนี้เราควบคุม RGB LED ได้อย่างเต็มที่ผ่าน Bluetooth Low Energy!

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

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

เขียนโค้ด

1. ขั้นแรกให้ลบโหมด MANUAL แสดงความคิดเห็น SYSTEM_MODE(MANUAL);

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

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

3. จากนั้นเริ่มต้นใน Setup()

    // Set to false at first
    m_publish = false;
   

4. จากนั้นหลังจากตั้งค่า 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;
   

5. มาเพิ่มเงื่อนไขใน 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 เพื่อสร้างสตริงที่มีค่าสีแดง สีเขียว และสีน้ำเงิน

6. จากนั้นมาสมัครตัวแปรเดียวกันใน Setup() . วิธีนี้จะทำให้อุปกรณ์อื่นทำให้ LED บนอุปกรณ์นี้อัปเดตได้เช่นกัน

    Mesh.subscribe("red", meshHandler);
    Mesh.subscribe("green", meshHandler);
    Mesh.subscribe("blue", meshHandler);
   

7. ไปที่ด้านบนของไฟล์เราต้องการสร้าง meshHandler

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

8. ในแอปพลิเคชันนี้ เราต้องการ event พารามิเตอร์และ data พารามิเตอร์. ในการใช้งาน เราต้องเปลี่ยนเป็น String พิมพ์. ด้วยวิธีนี้ เราจึงสามารถใช้ฟังก์ชันการแปลงและการเปรียบเทียบในตัวได้ ดังนั้น ภายใน meshHandler เพิ่มฟังก์ชัน:

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

9. ในที่สุดเราก็ทำการเปรียบเทียบ ก่อนอื่นเราตรวจสอบว่าชื่อเหตุการณ์ตรงกันหรือไม่ จากนั้นเราก็ตั้งค่า 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 ส่วน. เป็นการดีเสมอที่จะกรองเงื่อนไขข้อผิดพลาดก่อนที่จะสร้างความเสียหาย!

ทดสอบโค้ด

1. เปิดแอปอนุภาคในโทรศัพท์ของคุณ

2. มาตั้งค่าอาร์กอนกันก่อน หากไม่กะพริบเป็นสีน้ำเงิน ให้กดปุ่มโหมดค้างไว้จนกว่าจะกะพริบเป็นสีน้ำเงิน

   

   หมายเหตุ:หากคุณได้ตั้งโปรแกรมแอปไว้แล้ว ไฟ LED จะดับตามค่าเริ่มต้น กดปุ่มโหมดค้างไว้ 5 วินาทีแล้วดำเนินการต่อ

3. เข้าสู่กระบวนการจับคู่ แอพจะแนะนำคุณทุกขั้นตอน อย่าลืมจำรหัสผ่านผู้ดูแลระบบสำหรับเครือข่ายเมชของคุณ

   

   

   

   

4. ตั้งโปรแกรม Argon ด้วยเฟิร์มแวร์ล่าสุด (1.3.0) (ดู ขั้นตอนที่ 1 - เวลาทดสอบ - ขั้นตอนที่ 2 เพื่อเป็นเครื่องเตือนใจว่าต้องทำอย่างไร)

5. เมื่อกะพริบเป็นสีเหลืองอย่างรวดเร็ว ให้ตั้งโปรแกรม Argon ด้วยแอป Tinker สามารถดาวน์โหลดได้ที่หน้าเผยแพร่

6. เมื่อเรามีไฟ LED สีฟ้าที่เป็นของแข็ง (เชื่อมต่อกับ Particle Cloud) เราจะตั้งโปรแกรมแอป ใช้ Cloud Flash ในเมนูแบบเลื่อนลง

   

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

   ตรวจสอบว่าคุณเลือกเวอร์ชันของอุปกรณ์ OS ที่ถูกต้อง (1.3.0-rc1 ) ประเภทอุปกรณ์ (อาร์กอน ) และชื่ออุปกรณ์ (สิ่งที่คุณตั้งชื่อระหว่างการตั้งค่า )

7. เชื่อมต่อกับซีนอนโดยใช้แอปโทรศัพท์

8. เชื่อมต่อ Xenon กับเครือข่าย Mesh ของคุณโดยใช้แอปโทรศัพท์

9. แฟลช Xenon ของคุณโดยใช้ Cloud Flash . ใช้ชื่อที่คุณตั้งไว้ระหว่างการตั้งค่าแอพโทรศัพท์ ตราบใดที่อุปกรณ์เชื่อมต่อกับ Particle Cloud หรืออยู่ในเซฟโหมด (Purple LED) ก็ควรตั้งโปรแกรม

   

   

10. เมื่อเชื่อมต่อแล้ว มาที่ส่วนที่สนุกกัน เปิด Light Blue Explorer เชื่อมต่อกับ อาร์กอน หรือ ซีนอน .

    

11. เลือกคุณสมบัติ 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 . สมัครสมาชิกรายการของฉันสำหรับการอัปเดตและเนื้อหาภายใน นอกจากนี้ สมาชิกรุ่นแรกๆ ทุกคนจะได้รับส่วนลดเมื่อเปิดตัว! คลิกที่นี่เพื่อสมัคร