Bluetoothモジュールを用いてArduinoとiOSアプリを接続したい

実現したいこと

アプリ作成初心者なので至らないところがあると思います。
Xcode 12.3
Swift 5
iOS 14.2
ArduinoからをBluetoothで送信して、iPhoneでデータを受け取るアプリを作成しています。
質問内容としては、ログをみるとスキャンはできているのですが、それ以降うまくいっていないということです。

ログ

![イメージ説明](39bb3106b1c682763018ac598f3a1f3e.png)

コード

swift
1import UIKit
2import CoreBluetooth
3import os
4class CentralViewController: UIViewController {
5    @IBOutlet var textView: UITextView!
6    var centralManager: CBCentralManager!
7    var discoveredPeripheral: CBPeripheral?
8    var transferCharacteristic: CBCharacteristic?
9    var writeIterationsComplete = 0
10    var connectionIterationsComplete = 0
11    let defaultIterations = 5    
12    var data = Data()
13    override func viewDidLoad() {
14        centralManager = CBCentralManager(delegate: self, queue: nil, options: [CBCentralManagerOptionShowPowerAlertKey: true])
15        super.viewDidLoad()
16    }
17    override func viewWillDisappear(_ animated: Bool) {
18        centralManager.stopScan()
19        os_log("Scanning stopped")
20        data.removeAll(keepingCapacity: false)
21        super.viewWillDisappear(animated)
22    }
23    private func retrievePeripheral() {
24        let connectedPeripherals: [CBPeripheral] = (centralManager.retrieveConnectedPeripherals(withServices: [TransferService.serviceUUID]))
25        os_log("Found connected Peripherals with transfer service: %@", connectedPeripherals)
26        if let connectedPeripheral = connectedPeripherals.last {
27            os_log("Connecting to peripheral %@", connectedPeripheral)
28			self.discoveredPeripheral = connectedPeripheral
29            centralManager.connect(connectedPeripheral, options: nil)
30        } else {
31            centralManager.scanForPeripherals(withServices: [TransferService.serviceUUID],
32                                               options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
33        }
34    }
35    private func cleanup() {
36        guard let discoveredPeripheral = discoveredPeripheral,
37            case .connected = discoveredPeripheral.state else { return }
38        for service in (discoveredPeripheral.services ?? [] as [CBService]) {
39            for characteristic in (service.characteristics ?? [] as [CBCharacteristic]) {
40                if characteristic.uuid == TransferService.characteristicUUID && characteristic.isNotifying {
41                    self.discoveredPeripheral?.setNotifyValue(false, for: characteristic)
42                }
43            }
44        }
45        centralManager.cancelPeripheralConnection(discoveredPeripheral)
46    }
47    private func writeData() {
48        guard let discoveredPeripheral = discoveredPeripheral,
49                let transferCharacteristic = transferCharacteristic
50            else { return }
51        while writeIterationsComplete < defaultIterations && discoveredPeripheral.canSendWriteWithoutResponse {
52            let mtu = discoveredPeripheral.maximumWriteValueLength (for: .withoutResponse)
53            var rawPacket = [UInt8]()
54            let bytesToCopy: size_t = min(mtu, data.count)
55			data.copyBytes(to: &rawPacket, count: bytesToCopy)
56            let packetData = Data(bytes: &rawPacket, count: bytesToCopy)
57			
58			let stringFromData = String(data: packetData, encoding: .utf8)
59			os_log("Writing %d bytes: %s", bytesToCopy, String(describing: stringFromData))
60			
61            discoveredPeripheral.writeValue(packetData, for: transferCharacteristic, type: .withoutResponse)
62            writeIterationsComplete += 1
63        }
64        if writeIterationsComplete == defaultIterations {   
65            discoveredPeripheral.setNotifyValue(false, for: transferCharacteristic)
66        }
67    }
68}
69extension CentralViewController: CBCentralManagerDelegate {
70    internal func centralManagerDidUpdateState(_ central: CBCentralManager) {
71        switch central.state {
72        case .poweredOn:           
73            os_log("CBManager is powered on")
74            retrievePeripheral()
75        case .poweredOff:
76            os_log("CBManager is not powered on")
77            return
78        case .resetting:
79            os_log("CBManager is resetting")
80            return
81        case .unauthorized:
82            if #available(iOS 13.0, *) {
83                switch central.authorization {
84                case .denied:
85                    os_log("You are not authorized to use Bluetooth")
86                case .restricted:
87                    os_log("Bluetooth is restricted")
88                default:
89                    os_log("Unexpected authorization")
90                }
91            } else {
92            }
93            return
94        case .unknown:
95            os_log("CBManager state is unknown")
96            return
97        case .unsupported:
98            os_log("Bluetooth is not supported on this device")
99            return
100        @unknown default:
101            os_log("A previously unknown central manager state occurred")
102            return
103        }
104    }
105    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral,
106                        advertisementData: [String: Any], rssi RSSI: NSNumber) {
107        guard RSSI.intValue >= -50
108            else {
109                os_log("Discovered perhiperal not in expected range, at %d", RSSI.intValue)
110                return
111        }
112        os_log("Discovered %s at %d", String(describing: peripheral.name), RSSI.intValue)
113        if discoveredPeripheral != peripheral {
114            discoveredPeripheral = peripheral
115            os_log("Connecting to perhiperal %@", peripheral)
116            centralManager.connect(peripheral, options: nil)
117        }
118    }
119    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
120        os_log("Failed to connect to %@. %s", peripheral, String(describing: error))
121        cleanup()
122    }
123    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
124        os_log("Peripheral Connected")
125        centralManager.stopScan()
126        os_log("Scanning stopped")
127        connectionIterationsComplete += 1
128        writeIterationsComplete = 0
129        data.removeAll(keepingCapacity: false)
130        peripheral.delegate = self
131        peripheral.discoverServices([TransferService.serviceUUID])
132    }
133    
134    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
135        os_log("Perhiperal Disconnected")
136        discoveredPeripheral = nil
137        if connectionIterationsComplete < defaultIterations {
138            retrievePeripheral()
139        } else {
140            os_log("Connection iterations completed")
141        }
142    }
143}
144extension CentralViewController: CBPeripheralDelegate {
145    func peripheral(_ peripheral: CBPeripheral, didModifyServices invalidatedServices: [CBService]) {
146        
147        for service in invalidatedServices where service.uuid == TransferService.serviceUUID {
148            os_log("Transfer service is invalidated - rediscover services")
149            peripheral.discoverServices([TransferService.serviceUUID])
150        }
151    }
152
153    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
154        if let error = error {
155            os_log("Error discovering services: %s", error.localizedDescription)
156            cleanup()
157            return
158        }
159        guard let peripheralServices = peripheral.services else { return }
160        for service in peripheralServices {
161            peripheral.discoverCharacteristics([TransferService.characteristicUUID], for: service)
162        }
163    }
164    
165    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
166        
167        if let error = error {
168            os_log("Error discovering characteristics: %s", error.localizedDescription)
169            cleanup()
170            return
171        }
172        guard let serviceCharacteristics = service.characteristics else { return }
173        for characteristic in serviceCharacteristics where characteristic.uuid == TransferService.characteristicUUID {
174            
175            transferCharacteristic = characteristic
176            peripheral.setNotifyValue(true, for: characteristic)
177            print("OK")
178        }
179    }
180    
181    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
182       
183        if let error = error {
184            os_log("Error discovering characteristics: %s", error.localizedDescription)
185            cleanup()
186            return
187        }
188        guard let characteristicData = characteristic.value,
189            let stringFromData = String(data: characteristicData, encoding: .utf8) else { return }
190        os_log("Received %d bytes: %s", characteristicData.count, stringFromData)
191        if stringFromData == "EOM" {
192            DispatchQueue.main.async() {
193                self.textView.text = String(data: self.data, encoding: .utf8)
194            }
195            writeData()
196        } else {
197            data.append(characteristicData)
198        }
199    }
200    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
201        if let error = error {
202            os_log("Error changing notification state: %s", error.localizedDescription)
203            return
204        }
205        guard characteristic.uuid == TransferService.characteristicUUID else { return }
206        if characteristic.isNotifying {
207os_log("Notification began on %@", characteristic)
208        } else {
209os_log("Notification stopped on %@. Disconnecting", characteristic)
210            cleanup()
211        }
212    }
213    func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {
214        os_log("Peripheral is ready, send data")
215        writeData()
216    }
217}

試したこと

Light Blueを使用して接続とデータ送信できました。

hoshi-takanori

2021/01/17 05:12

画像はこれですね。 https://teratail-v2.storage.googleapis.com/uploads/contributed_images/39bb3106b1c682763018ac598f3a1f3e.png Bluetooth は何も分かりませんが、discoverServices 以降はログ出力をあまりしてないようなので、discoverServices に nil を渡して何が返るかぜんぶ表示するとかしてみては。