[移动开发]uniapp微信小程序实现连接低功耗蓝牙打印功能

微信小程序项目中有使用到蓝牙连接打印，参考官方文档做了一个参考笔记，这样使用的时候就按着步骤查看。

uni-app蓝牙连接

蓝牙：

1、初始化蓝牙

uni.openBluetoothAdapter(OBJECT)

uni.openBluetoothAdapter({
  success(res) {
    console.log(res)
    // 接口调用成功的回调函数
  },
  fail:(res)=>{
      // 接口调用失败的回调函数
  },
  complete:()=>{
	// 接口调用结束的回调函数（调用成功、失败都会执行）
  }
})

错误 ：res.errCode

注意

• 其他蓝牙相关 API 必须在 uni.openBluetoothAdapter 调用之后使用。否则 API 会返回错误（errCode=10000）。
• 在用户蓝牙开关未开启或者手机不支持蓝牙功能的情况下，调用 uni.openBluetoothAdapter 会返回错误（errCode=10001），表示手机蓝牙功能不可用。此时APP蓝牙模块已经初始化完成，可通过 uni.onBluetoothAdapterStateChange 监听手机蓝牙状态的改变，也可以调用蓝牙模块的所有API。

2、监听蓝牙适配器状态变化事件

uni.onBluetoothAdapterStateChange(CALLBACK)

CALLBACK 返回参数

示例代码

uni.onBluetoothAdapterStateChange((res) => {
    console.log('onBluetoothAdapterStateChange', res)
    // available：蓝牙适配器是否可用
    if (res.available) {
        // 取消监听，否则stopBluetoothDevicesDiscovery后仍会继续触发onBluetoothAdapterStateChange，
        // 导致再次调用startBluetoothDevicesDiscovery
        uni.onBluetoothAdapterStateChange(() => {});
        // 开始搜寻附近的蓝牙外围设备
        uni.startBluetoothDevicesDiscovery(OBJECT)
    }
})

3、开始搜寻附近的蓝牙外围设备

uni.startBluetoothDevicesDiscovery(OBJECT)

此操作比较耗费系统资源，请在搜索并连接到设备后调用 uni.stopBluetoothDevicesDiscovery 方法停止搜索。

OBJECT 参数说明

错误

注意：

• App 端目前仅支持发现ble蓝牙设备，更多蓝牙设备发现，可以使用 Native.js，参考：https://ask.dcloud.net.cn/article/114。也可以在插件市场获取原生插件

示例代码

// 以微信硬件平台的蓝牙智能灯为例，主服务的 UUID 是 FEE7。传入这个参数，只搜索主服务 UUID 为 FEE7 的设备
uni.startBluetoothDevicesDiscovery({
  services: ['FEE7'],
  success(res) {
    console.log(res)
    // 监听寻找到新设备的事件
    uni.onBluetoothDeviceFound(OBJECT)
  }
})

4、监听寻找到新设备的事件

uni.onBluetoothDeviceFound(CALLBACK)

CALLBACK 返回参数

devices 的结构

注意

• 若在 uni.onBluetoothDeviceFound 回调了某个设备，则此设备会添加到 uni.getBluetoothDevices 接口获取到的数组中。

示例代码

// ArrayBuffer转16进度字符串示例
function ab2hex(buffer) {
  const hexArr = Array.prototype.map.call(
    new Uint8Array(buffer),
    function (bit) {
      return ('00' + bit.toString(16)).slice(-2)
    }
  )
  return hexArr.join('')
}
uni.onBluetoothDeviceFound(function (devices) {
  console.log('new device list has founded')
  console.dir(devices)
  console.log(ab2hex(devices[0].advertisData))
})

5、停止搜寻附近的蓝牙外围设备

uni.stopBluetoothDevicesDiscovery(OBJECT)

若已经找到需要的蓝牙设备并不需要继续搜索时，建议调用该接口停止蓝牙搜索。

OBJECT 参数说明

错误

示例代码

uni.stopBluetoothDevicesDiscovery({
  success(res) {
    console.log(res)
  }
})

6、根据 uuid 获取处于已连接状态的设备

uni.getConnectedBluetoothDevices(OBJECT)

OBJECT 参数说明

success 返回参数说明：

res.devices 的结构

错误

示例代码

uni.getConnectedBluetoothDevices({
  success(res) {
    console.log(res)
  }
})

7、获取在蓝牙模块生效期间所有已发现的蓝牙设备

uni.getBluetoothDevices(OBJECT)

包括已经和本机处于连接状态的设备。

OBJECT 参数说明

success 返回参数说明：

res.devices 的结构

错误

示例代码

// ArrayBuffer转16进度字符串示例
function ab2hex(buffer) {
  const hexArr = Array.prototype.map.call(
    new Uint8Array(buffer),
    function (bit) {
      return ('00' + bit.toString(16)).slice(-2)
    }
  )
  return hexArr.join('')
}
uni.getBluetoothDevices({
  success(res) {
    console.log(res)
    if (res.devices[0]) {
      console.log(ab2hex(res.devices[0].advertisData))
    }
  }
})

注意

• 该接口获取到的设备列表为蓝牙模块生效期间所有搜索到的蓝牙设备，若在蓝牙模块使用流程结束后未及时调用 uni.closeBluetoothAdapter 释放资源，会存在调用该接口会返回之前的蓝牙使用流程中搜索到的蓝牙设备，可能设备已经不在用户身边，无法连接。
• 蓝牙设备在被搜索到时，系统返回的 name 字段一般为广播包中的 LocalName 字段中的设备名称，而如果与蓝牙设备建立连接，系统返回的 name 字段会改为从蓝牙设备上获取到的 GattName。若需要动态改变设备名称并展示，建议使用 localName 字段。

8、获取本机蓝牙适配器状态

uni.getBluetoothAdapterState(OBJECT)

OBJECT 参数说明

success 返回参数说明：

错误

示例代码

uni.getBluetoothAdapterState({
  success(res) {
    console.log(res)
  }
})

9、关闭蓝牙模块

uni.closeBluetoothAdapter(OBJECT)

调用该方法将断开所有已建立的连接并释放系统资源。建议在使用蓝牙流程后，与 uni.openBluetoothAdapter 成对调用。

OBJECT 参数说明

错误

示例代码

uni.closeBluetoothAdapter({
  success(res) {
    console.log(res)
  }
})

低功耗蓝牙：

1、设置蓝牙最大传输单元

[uni.setBLEMTU(OBJECT)

需在 uni.createBLEConnection调用成功后调用，mtu 设置范围 (22,512)。安卓5.1以上有效。

OBJECT 参数说明

2、向低功耗蓝牙设备特征值中写入二进制数据

uni.writeBLECharacteristicValue(OBJECT)

注意：必须设备的特征值支持 write 才可以成功调用。

OBJECT 参数说明

错误

注意

• 并行调用多次会存在写失败的可能性。
• APP不会对写入数据包大小做限制，但系统与蓝牙设备会限制蓝牙4.0单次传输的数据大小，超过最大字节数后会发生写入错误，建议每次写入不超过20字节。
• 若单次写入数据过长，iOS 上存在系统不会有任何回调的情况（包括错误回调）。
• 安卓平台上，在调用 notifyBLECharacteristicValueChange 成功后立即调用 writeBLECharacteristicValue 接口，在部分机型上会发生 10008 系统错误

示例代码

// 向蓝牙设备发送一个0x00的16进制数据
const buffer = new ArrayBuffer(1)
const dataView = new DataView(buffer)
dataView.setUint8(0, 0)
uni.writeBLECharacteristicValue({
  // 这里的 deviceId 需要在 getBluetoothDevices 或 onBluetoothDeviceFound 接口中获取
  deviceId,
  // 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
  serviceId,
  // 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
  characteristicId,
  // 这里的value是ArrayBuffer类型
  value: buffer,
  success(res) {
    console.log('writeBLECharacteristicValue success', res.errMsg)
  }
})

3、读取低功耗蓝牙设备的特征值的二进制数据值

uni.readBLECharacteristicValue(OBJECT)

注意：必须设备的特征值支持 read 才可以成功调用。

OBJECT 参数说明

错误

注意

• 并行调用多次会存在读失败的可能性。
• 接口读取到的信息需要在 onBLECharacteristicValueChange 方法注册的回调中获取。

示例代码

// 必须在这里的回调才能获取
uni.onBLECharacteristicValueChange(function (characteristic) {
  console.log('characteristic value comed:', characteristic)
})
uni.readBLECharacteristicValue({
  // 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
  deviceId,
  // 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
  serviceId,
  // 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
  characteristicId,
  success(res) {
    console.log('readBLECharacteristicValue:', res.errCode)
  }
})

4、监听低功耗蓝牙连接状态的改变事件

uni.onBLEConnectionStateChange(CALLBACK)

包括开发者主动连接或断开连接，设备丢失，连接异常断开等等

CALLBACK 返回参数

示例代码

uni.onBLEConnectionStateChange(function (res) {
  // 该方法回调中可以用于处理连接意外断开等异常情况
  console.log(`device ${res.deviceId} state has changed, connected: ${res.connected}`)
})

5、监听低功耗蓝牙设备的特征值变化事件

uni.onBLECharacteristicValueChange(CALLBACK)

必须先启用 notifyBLECharacteristicValueChange 接口才能接收到设备推送的 notification。

CALLBACK 返回参数

示例代码

// ArrayBuffer转16进度字符串示例
function ab2hex(buffer) {
  const hexArr = Array.prototype.map.call(
    new Uint8Array(buffer),
    function (bit) {
      return ('00' + bit.toString(16)).slice(-2)
    }
  )
  return hexArr.join('')
}
uni.onBLECharacteristicValueChange(function (res) {
  console.log(`characteristic ${res.characteristicId} has changed, now is ${res.value}`)
  console.log(ab2hex(res.value))
})

6、订阅特征值

uni.notifyBLECharacteristicValueChange(OBJECT)

启用低功耗蓝牙设备特征值变化时的 notify 功能，订阅特征值。注意：必须设备的特征值支持 notify 或者 indicate 才可以成功调用。 另外，必须先启用 notifyBLECharacteristicValueChange 才能监听到设备 characteristicValueChange 事件

OBJECT 参数说明

错误

注意

• 订阅操作成功后需要设备主动更新特征值的 value，才会触发 uni.onBLECharacteristicValueChange 回调。
• 安卓平台上，在调用 notifyBLECharacteristicValueChange 成功后立即调用 writeBLECharacteristicValue 接口，在部分机型上会发生 10008 系统错误

示例代码

uni.notifyBLECharacteristicValueChange({
  state: true, // 启用 notify 功能
  // 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
  deviceId,
  // 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
  serviceId,
  // 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
  characteristicId,
  success(res) {
    console.log('notifyBLECharacteristicValueChange success', res.errMsg)
  }
})

7、获取蓝牙设备所有服务(service)

uni.getBLEDeviceServices(OBJECT)

OBJECT 参数说明

success 返回参数说明：

res.services 的结构

错误

示例代码

uni.getBLEDeviceServices({
  // 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
  deviceId,
  success(res) {
    console.log('device services:', res.services)
  }
})

8、获取蓝牙设备的信号强度

uni.getBLEDeviceRSSI(OBJECT)

OBJECT 参数说明

9、获取蓝牙设备某个服务中所有特征值(characteristic)。

uni.getBLEDeviceCharacteristics(OBJECT)

OBJECT 参数说明

success 返回参数说明：

res.characteristics 的结构

properties 的结构

错误

示例代码

uni.getBLEDeviceCharacteristics({
  // 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
  deviceId,
  // 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
  serviceId,
  success(res) {
    console.log('device getBLEDeviceCharacteristics:', res.characteristics)
  }
})

10、连接低功耗蓝牙设备

uni.createBLEConnection(OBJECT)

若APP在之前已有搜索过某个蓝牙设备，并成功建立连接，可直接传入之前搜索获取的 deviceId 直接尝试连接该设备，无需进行搜索操作。

OBJECT 参数说明

错误

注意

• 请保证尽量成对的调用 createBLEConnection 和 closeBLEConnection 接口。安卓如果多次调用 createBLEConnection 创建连接，有可能导致系统持有同一设备多个连接的实例，导致调用 closeBLEConnection 的时候并不能真正的断开与设备的连接。
• 蓝牙连接随时可能断开，建议监听 uni.onBLEConnectionStateChange 回调事件，当蓝牙设备断开时按需执行重连操作
• 若对未连接的设备或已断开连接的设备调用数据读写操作的接口，会返回 10006 错误，建议进行重连操作。

示例代码

uni.createBLEConnection({
  // 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
  deviceId,
  success(res) {
    console.log(res)
  }
})

11、断开与低功耗蓝牙设备的连接。

uni.closeBLEConnection(OBJECT)

OBJECT 参数说明

错误

示例代码

uni.closeBLEConnection({
  deviceId,
  success(res) {
    console.log(res)
  }
})

实现代码：

<script>
const LAST_CONNECTED_DEVICE = 'last_connected_device';
import PrinterJobs from '../../common/printer/printerjobs';
import printerUtil from '../../common/printer/printerutil';

function inArray(arr, key, val) {
	for (let i = 0; i < arr.length; i++) {
		if (arr[i][key] === val) {
			return i;
		}
	}
	return -1;
}

// ArrayBuffer转16进度字符串示例
function ab2hex(buffer) {
	const hexArr = Array.prototype.map.call(new Uint8Array(buffer), function(bit) {
		return ('00' + bit.toString(16)).slice(-2);
	});
	return hexArr.join(',');
}

function str2ab(str) {
	// Convert str to ArrayBuff and write to printer
	let buffer = new ArrayBuffer(str.length);
	let dataView = new DataView(buffer);
	for (let i = 0; i < str.length; i++) {
		dataView.setUint8(i, str.charAt(i).charCodeAt(0));
	}
	return buffer;
}

export default {
	data() {
		return {
			devices:[]  // 搜索到的设备
		}
	};
},
onLoad(e) {
	this.openBluetoothAdapter()  // 初始化蓝牙模块
},
methods: {
	// 初始化蓝牙模块
		openBluetoothAdapter() {
			console.log('初始化蓝牙模块 openBluetoothAdapter');
			if (!uni.openBluetoothAdapter) {
				console.log('微信版本过低');
				uni.showModal({
					title: this.$t('wechat.w102'), //'提示',
					content: this.$t('wechat.w226') //'当前微信版本过低，无法使用该功能，请升级到最新微信版本后重试。'
				});
				return;
			}
			uni.openBluetoothAdapter({
				success: res => {
					console.log('初始化成功openBluetoothAdapter success', res);
					// 搜寻附近的蓝牙
					this.startBluetoothDevicesDiscovery();
				},
				fail: res => {
					console.log('初始化失败openBluetoothAdapter fail', res);
					if (res.errCode === 10001) {
						uni.showModal({
							title: this.$t('wechat.w227'), //错误
							content: this.$t('wechat.w228'), //'未找到蓝牙设备, 请打开蓝牙后重试。',
							showCancel: false
						});
						// 监听蓝牙适配器状态变化事件
						uni.onBluetoothAdapterStateChange(res => {
							console.log('监听蓝牙适配器状态 onBluetoothAdapterStateChange', res);
							// available：蓝牙适配器是否可用
							if (res.available) {
								// 取消监听，否则stopBluetoothDevicesDiscovery后仍会继续触发onBluetoothAdapterStateChange，
								// 导致再次调用startBluetoothDevicesDiscovery
								// uni.onBluetoothAdapterStateChange(() => {});
								// 开始搜寻附近的蓝牙外围设备
								this.startBluetoothDevicesDiscovery();
							}
						});
					}
				}
			});
		},
		// 开始搜寻附近的蓝牙外围设备
		startBluetoothDevicesDiscovery() {
			if (this._discoveryStarted) {
				return;
			}
			this._discoveryStarted = true;
			uni.startBluetoothDevicesDiscovery({
				allowDuplicatesKey: false,
				interval: 0,
				success: res => {
					console.log('搜寻附近的蓝牙外围设备 startBluetoothDevicesDiscovery success111', res);
					// 监听寻找到新设备的事件
					this.onBluetoothDeviceFound();
				},
				fail: res => {
					console.log('搜寻附近的蓝牙外围设备 startBluetoothDevicesDiscovery fail', res);
				}
			});
		},
		// 监听寻找到新设备的事件
		onBluetoothDeviceFound() {
			console.log('进入查询设备');
			uni.onBluetoothDeviceFound(res => {
				console.log('寻找设备', res.devices);
				res.devices.forEach(device => {
					if (!device.name && !device.localName) {
						return;
					}
					const foundDevices = this.devices;
					const idx = inArray(foundDevices, 'deviceId', device.deviceId);
					const data = {};
					if (idx === -1) {
						this.$set(this.devices, `${foundDevices.length}`, device);
					} else {
						this.$set(this.devices, `${idx}`, device);
					}
					// console.log('搜索结果',this.devices)
				});
			});
		},
		
		// this.devices是蓝牙设备列表，渲染到页面显示点击执行蓝牙连接
		// 点击链接蓝牙
		createBLEConnection(e) {
			console.log('点击连接蓝牙', e);
			const deviceId = e.deviceId;
			const name = e.name;
			this._createBLEConnection(deviceId, name);
		},
		// 连接蓝牙设备
		_createBLEConnection(deviceId, name) {
			this.$myToast(this.$t('wechat.w224'), 'loading'); //连接设备中
			// 连接低功耗蓝牙设备
			uni.createBLEConnection({
				deviceId, // 用于区分设备的 id
				success: () => {
					console.log('连接蓝牙接口调用成功 createBLEConnection success', this.devices);
					this.devices.forEach((item, index) => {
						this.$set(this.devices[index], 'isShowConnect', false);
						if (item.deviceId === deviceId) {
							this.$set(this.devices[index], 'isShowConnect', true);
						}
					});
					this.$myToast(this.$t('wechat.w225'), 'success'); //设备连接成功
					this.connected = true;
					this.isConnected = false;
					this.name = name;
					this.deviceId = deviceId;
					// 获取蓝牙设备所有服务(service)
					this.getBLEDeviceServices(deviceId);
					// 最后连接设备
					uni.setStorage({
						key: LAST_CONNECTED_DEVICE,
						data: name + ':' + deviceId
					});
				},
				complete() {
					uni.hideLoading();
				},
				fail: res => {
					// 连接蓝牙接口调用失败
					console.log('连接蓝牙接口调用失败 createBLEConnection fail', res);
					uni.showModal({
						title: this.$t('wechat.w227'),
						content: '蓝牙连接失败',
						showCancel: false
					});
				}
			});
			// 已经找到需要的蓝牙设备,停止搜寻附近的蓝牙外围设备
			this.stopBluetoothDevicesDiscovery();
		},
		// 获取蓝牙设备所有服务(service)
		getBLEDeviceServices(deviceId) {
			uni.getBLEDeviceServices({
				deviceId,
				success: res => {
					console.log('获取蓝牙设备所有服务 getBLEDeviceServices', res);
					for (let i = 0; i < res.services.length; i++) {
						if (res.services[i].isPrimary) {
							this.getBLEDeviceCharacteristics(deviceId, res.services[i].uuid);
							return;
						}
					}
				}
			});
		},
		stopBluetoothDevicesDiscovery() {
			uni.stopBluetoothDevicesDiscovery({
				complete: () => {
					// console.log('stopBluetoothDevicesDiscovery')
					this._discoveryStarted = false;
				}
			});
		},
		/*
				获取蓝牙设备某个服务中所有特征值(characteristic)
				characteristic:
					uuid:蓝牙设备特征值的 uuid
					properties:该特征值支持的操作类型
			*/
		getBLEDeviceCharacteristics(deviceId, serviceId) {
			uni.getBLEDeviceCharacteristics({
				// 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
				deviceId,
				// 这里的 serviceId(蓝牙服务 uuid) 需要在 getBLEDeviceServices 接口中获取
				serviceId,
				success: res => {
					console.log('特征值变化 getBLEDeviceCharacteristics success', res.characteristics);
					// 这里会存在特征值是支持write，写入成功但是没有任何反应的情况
					// 只能一个个去试
					// characteristics：设备服务列表
					for (let i = 0; i < res.characteristics.length; i++) {
						const item = res.characteristics[i];
						// if (item.properties.read) {
						// 	uni.readBLECharacteristicValue({
						// 		deviceId,
						// 		serviceId,
						// 		characteristicId: item.uuid
						// 	})
						// }

						if (item.properties.write) {
							this.canWrite = true;
							this._deviceId = deviceId;
							this._serviceId = serviceId;
							this._characteristicId = item.uuid;
						}

						if (item.properties.notify || item.properties.indicate) {
							uni.notifyBLECharacteristicValueChange({
								deviceId,
								serviceId,
								characteristicId: item.uuid,
								state: true
							});
						}
					}
				},
				fail(res) {
					console.error('特征值变化 getBLEDeviceCharacteristics', res);
				}
			});
		},
		
		// 蓝牙连接成功后点击打印，打印数据
		// 点击打印：写入数据（根据项目需要打印内容来实现）
		writeBLECharacteristicValue() {
			this.isLoading = true;
			setTimeout(() => {
				this.isDisabled = false;
				this.isLoading = false;
			}, 3000);
			let printerJobs = new PrinterJobs();
			const { channels, header, dataList } = this.printInfo;
			// console.log('通道数据', dataList)
			let title = '';
			header.forEach(item => {
				title = `${item.name}  `;
			});
			// 要打印的头部信息
			printerJobs
				.setAlign('ct')
				.setSize(2, 2)
				.print(this.$t('wechat.w221')) //'记录报告'
				.setSize(0, 0)
				.print()
				.setAlign('lt')
				.setSize(1, 1)
				.print(`${this.$t('wechat.w51')}：${this.info.name}`) //设备名称
				.print(`${this.$t('wechat.w76')}：${this.info.modelName}`) //设备型号
				.print(`${this.$t('wechat.w46')}：${this.info.deviceSerial}`) //序列号
				.print(`${this.$t('wechat.w100')}：${this.userInfo.relName}`) //用户名
				.print(`${this.$t('wechat.w101')}：${this.remark}`); //备注
			if (this.isEn) {
				channels.forEach(item => {
					printerJobs
						.print(`${item.name}(Max)：${item.max}${item.unitIcon}`)
						.print(`${this.$t('wechat.w148')}：${this.$timestampToTimeEn(item.maxDate)}`) //时间
						.print(`${item.name}(Min)：${item.min}${item.unitIcon}`)
						.print(`${this.$t('wechat.w148')}：${this.$timestampToTimeEn(item.minDate)}`); //时间
				});
			} else {
				channels.forEach(item => {
					printerJobs
						.print(`${item.name}(Max)：${item.max}${item.unitIcon}`)
						.print(`${this.$t('wechat.w148')}：${this.$timestampToTime2(item.maxDate)}`) //时间
						.print(`${item.name}(Min)：${item.min}${item.unitIcon}`)
						.print(`${this.$t('wechat.w148')}：${this.$timestampToTime2(item.minDate)}`); //时间
				});
			}

			printerJobs.print(printerUtil.fillLine()).setSize(1, 1);
			let titleStr = '';
			header.forEach((item, index) => {
				titleStr = titleStr + `${index === 0 ? '' : '    '}` + `${item.name}`;
			});
			printerJobs.print(printerUtil.inline(this.$t('wechat.w222'), `${titleStr}`)); //记录时间

			// 打印'----------------'
			printerJobs.print(printerUtil.fillLine());
			// 要打印的内容：
			dataList.forEach(item => {
				let str = '';
				header.forEach((item2, index2) => {
					// 暂无
					str = str + `${index2 === 0 ? '' : '  '}` + `${item[item2.columnName] ? item[item2.columnName].toFixed(2) : this.$t('wechat.w71empty')}`;
				});

				if (this.isEn) {
					printerJobs.print(printerUtil.inline(`${this.$timestampToTimeEn2(item.dataTime)}`, `${str}`));
				} else {
					printerJobs.print(printerUtil.inline(`${this.$timestampToTime3(item.dataTime)}`, `${str}`));
				}
				// console.log(`${item.dataTime}`, str);
			});
			// 结尾
			printerJobs
				.println()
				.print(`${this.$t('wechat.w223')}：`) //'签名
				.println()
				.println();

			let buffer = printerJobs.buffer();
			// console.log('ArrayBuffer', 'length: ' + buffer.byteLength, ' hex: ' + ab2hex(buffer));
			// 1.并行调用多次会存在写失败的可能性
			// 2.建议每次写入不超过20字节
			// 分包处理，延时调用
			const maxChunk = 20;
			const delay = 40;
			for (let i = 0, j = 0, length = buffer.byteLength; i < length; i += maxChunk, j++) {
				let subPackage = buffer.slice(i, i + maxChunk <= length ? i + maxChunk : length);
				// subPackage：参数
				setTimeout(this._writeBLECharacteristicValue, j * delay, subPackage);
			}
		},
		// 向低功耗蓝牙设备特征值中写入二进制数据。注意：必须设备的特征值支持 write 才可以成功调用。
		_writeBLECharacteristicValue(buffer) {
			uni.writeBLECharacteristicValue({
				deviceId: this._deviceId, // 蓝牙设备 id
				serviceId: this._serviceId, // 蓝牙特征值对应服务的 uuid
				characteristicId: this._characteristicId, // 蓝牙特征值的 uuid
				value: buffer, // 蓝牙设备特征值对应的二进制值
				success(res) {
					console.log('writeBLECharacteristicValue success', res);
				},
				fail(res) {
					console.log('writeBLECharacteristicValue fail', res);
				}
			});
		},
		
		



}

打印效果：

其他文件：

1. printerutil.js

// 打印机纸宽58mm，页的宽度384，字符宽度为1，每行最多盛放32个字符
const PAGE_WIDTH = 384;
const MAX_CHAR_COUNT_EACH_LINE = 32;

/**
 * @param str
 * @returns {boolean} str是否全是中文
 */
function isChinese(str) {
  return /^[\u4e00-\u9fa5]$/.test(str);
}

/**
 * 返回字符串宽度(1个中文=2个英文字符)
 * @param str
 * @returns {number}
 */
function getStringWidth(str) {
  let width = 0;
  for (let i = 0, len = str.length; i < len; i++) {
    width += isChinese(str.charAt(i)) ? 2 : 1;
  }
  return width;
}

/**
 * 同一行输出str1, str2，str1居左, str2居右
 * @param {string} str1 内容1
 * @param {string} str2 内容2
 * @param {number} fontWidth 字符宽度 1/2
 * @param {string} fillWith str1 str2之间的填充字符
 *
 */
function inline(str1, str2, fillWith = ' ', fontWidth = 1) {
  const lineWidth = MAX_CHAR_COUNT_EACH_LINE / fontWidth;
  // 需要填充的字符数量
  let fillCount = lineWidth - (getStringWidth(str1) + getStringWidth(str2)) % lineWidth;
  let fillStr = new Array(fillCount).fill(fillWith.charAt(0)).join('');
  return str1 + fillStr + str2;
}

/**
 * 用字符填充一整行
 * @param {string} fillWith 填充字符
 * @param {number} fontWidth 字符宽度 1/2
 */
function fillLine(fillWith = '-', fontWidth = 1) {
  const lineWidth = MAX_CHAR_COUNT_EACH_LINE / fontWidth;
  return new Array(lineWidth).fill(fillWith.charAt(0)).join('');
}

/**
 * 文字内容居中，左右用字符填充
 * @param {string} str 文字内容
 * @param {number} fontWidth 字符宽度 1/2
 * @param {string} fillWith str1 str2之间的填充字符
 */
function fillAround(str, fillWith = '-', fontWidth = 1) {
  const lineWidth = MAX_CHAR_COUNT_EACH_LINE / fontWidth;
  let strWidth = getStringWidth(str);
  // 内容已经超过一行了，没必要填充
  if (strWidth >= lineWidth) {
    return str;
  }
  // 需要填充的字符数量
  let fillCount = lineWidth - strWidth;
  // 左侧填充的字符数量
  let leftCount = Math.round(fillCount / 2);
  // 两侧的填充字符，需要考虑左边需要填充，右边不需要填充的情况
  let fillStr = new Array(leftCount).fill(fillWith.charAt(0)).join('');
  return fillStr + str + fillStr.substr(0, fillCount - leftCount);
}

module.exports = {
  inline: inline,
  fillLine: fillLine,
  fillAround: fillAround,
};

2. printerjobs.js

const commands = require('./commands.js');
const TextEncoder = require('../text-encoding/index').TextEncoder;

const printerJobs = function () {
  this._queue = Array.from(commands.HARDWARE.HW_INIT);
  this._encoder = new TextEncoder("gb2312", {NONSTANDARD_allowLegacyEncoding: true});
  this._enqueue = function (cmd) {
    this._queue.push.apply(this._queue, cmd);
  }
};

/**
 * 增加打印内容
 * @param  {string} content  文字内容
 */
printerJobs.prototype.text = function (content) {
  if (content) {
    let uint8Array = this._encoder.encode(content);
    let encoded = Array.from(uint8Array);
    this._enqueue(encoded);
  }
  return this;
};

/**
 * 打印文字
 * @param  {string} content  文字内容
 */
printerJobs.prototype.print = function (content) {
  this.text(content);
  this._enqueue(commands.LF);
  return this;
};

/**
 * 打印文字并换行
 * @param  {string}  content  文字内容
 */
printerJobs.prototype.println = function (content = '') {
  return this.print(content + commands.EOL);
};

/**
 * 设置对齐方式
 * @param {string} align 对齐方式 LT/CT/RT
 */
printerJobs.prototype.setAlign = function (align) {
  this._enqueue(commands.TEXT_FORMAT['TXT_ALIGN_' + align.toUpperCase()]);
  return this;
};

/**
 * 设置字体
 * @param  {string} family A/B/C
 */
printerJobs.prototype.setFont = function (family) {
  this._enqueue(commands.TEXT_FORMAT['TXT_FONT_' + family.toUpperCase()]);
  return this;
};

/**
 * 设定字体尺寸
 * @param  {number} width 字体宽度 1~2
 * @param  {number} height 字体高度 1~2
 */
printerJobs.prototype.setSize = function (width, height) {
  if (2 >= width && 2 >= height) {
    this._enqueue(commands.TEXT_FORMAT.TXT_NORMAL);
    if (2 === width && 2 === height) {
      this._enqueue(commands.TEXT_FORMAT.TXT_4SQUARE);
    } else if (1 === width && 2 === height) {
      this._enqueue(commands.TEXT_FORMAT.TXT_2HEIGHT);
    } else if (2 === width && 1 === height) {
      this._enqueue(commands.TEXT_FORMAT.TXT_2WIDTH);
    }
  }
  return this;
};

/**
 * 设定字体是否加粗
 * @param  {boolean} bold
 */
printerJobs.prototype.setBold = function (bold) {
  if (typeof bold !== 'boolean') {
    bold = true;
  }
  this._enqueue(bold ? commands.TEXT_FORMAT.TXT_BOLD_ON : commands.TEXT_FORMAT.TXT_BOLD_OFF);
  return this;
};

/**
 * 设定是否开启下划线
 * @param  {boolean} underline
 */
printerJobs.prototype.setUnderline = function (underline) {
  if (typeof underline !== 'boolean') {
    underline = true;
  }
  this._enqueue(underline ? commands.TEXT_FORMAT.TXT_UNDERL_ON : commands.TEXT_FORMAT.TXT_UNDERL_OFF);
  return this;
};

/**
 * 设置行间距为 n 点行,默认值行间距是 30 点
 * @param {number} n 0≤n≤255
 */
printerJobs.prototype.setLineSpacing = function (n) {
  if (n === undefined || n === null) {
    this._enqueue(commands.LINE_SPACING.LS_DEFAULT);
  } else {
    this._enqueue(commands.LINE_SPACING.LS_SET);
    this._enqueue([n]);
  }
  return this;
};

/**
 * 打印空行
 * @param {number} n
 */
printerJobs.prototype.lineFeed = function (n = 1) {
  return this.print(new Array(n).fill(commands.EOL).join(''));
};

/**
 *  设置字体颜色，需要打印机支持
 *  @param  {number} color - 0 默认颜色黑色 1 红色
 */
printerJobs.prototype.setColor = function (color) {
  this._enqueue(commands.COLOR[color === 1 ? 1 : 0]);
  return this;
};

/**
 * https://support.loyverse.com/hardware/printers/use-the-beeper-in-a-escpos-printers
 * 蜂鸣警报，需要打印机支持
 * @param  {number} n    蜂鸣次数,1-9
 * @param  {number} t 蜂鸣长短,1-9
 */
printerJobs.prototype.beep = function (n, t) {
  this._enqueue(commands.BEEP);
  this._enqueue([n, t]);
  return this;
};

/**
 * 清空任务
 */
printerJobs.prototype.clear = function () {
  this._queue = Array.from(commands.HARDWARE.HW_INIT);
  return this;
};

/**
 * 返回ArrayBuffer
 */
printerJobs.prototype.buffer = function () {
  return new Uint8Array(this._queue).buffer;
};

module.exports = printerJobs;

3. commands.js

/**
 * 修改自https://github.com/song940/node-escpos/blob/master/commands.js
 * ESC/POS _ (Constants)
 */
var _ = {
  LF: [0x0a],
  FS: [0x1c],
  FF: [0x0c],
  GS: [0x1d],
  DLE: [0x10],
  EOT: [0x04],
  NUL: [0x00],
  ESC: [0x1b],
  EOL: '\n',
};

/**
 * [FEED_CONTROL_SEQUENCES Feed control sequences]
 * @type {Object}
 */
_.FEED_CONTROL_SEQUENCES = {
  CTL_LF: [0x0a],   // Print and line feed 打印换行
  CTL_GLF: [0x4a, 0x00],   // Print and feed paper (without spaces between lines) 打印和送纸(行间无空格)
  CTL_FF: [0x0c],   // Form feed 换页
  CTL_CR: [0x0d],   // Carriage return
  CTL_HT: [0x09],   // Horizontal tab 回车
  CTL_VT: [0x0b],   // Vertical tab 垂直制表符
};

_.CHARACTER_SPACING = {
  CS_DEFAULT: [0x1b, 0x20, 0x00],
  CS_SET: [0x1b, 0x20]
};

_.LINE_SPACING = {
  LS_DEFAULT: [0x1b, 0x32],
  LS_SET: [0x1b, 0x33]
};

/**
 * [HARDWARE Printer hardware]
 * @type {Object}
 */
_.HARDWARE = {
  HW_INIT: [0x1b, 0x40], // Clear data in buffer and reset modes
  HW_SELECT: [0x1b, 0x3d, 0x01], // Printer select
  HW_RESET: [0x1b, 0x3f, 0x0a, 0x00], // Reset printer hardware
};

/**
 * [CASH_DRAWER Cash Drawer]
 * @type {Object}
 */
_.CASH_DRAWER = {
  CD_KICK_2: [0x1b, 0x70, 0x00], // Sends a pulse to pin 2 []
  CD_KICK_5: [0x1b, 0x70, 0x01], // Sends a pulse to pin 5 []
};

/**
 * [MARGINS Margins sizes]
 * @type {Object}
 */
_.MARGINS = {
  BOTTOM: [0x1b, 0x4f], // Fix bottom size
  LEFT: [0x1b, 0x6c], // Fix left size
  RIGHT: [0x1b, 0x51], // Fix right size
};

/**
 * [PAPER Paper]
 * @type {Object}
 */
_.PAPER = {
  PAPER_FULL_CUT: [0x1d, 0x56, 0x00], // Full cut paper
  PAPER_PART_CUT: [0x1d, 0x56, 0x01], // Partial cut paper
  PAPER_CUT_A: [0x1d, 0x56, 0x41], // Partial cut paper
  PAPER_CUT_B: [0x1d, 0x56, 0x42], // Partial cut paper
};

/**
 * [TEXT_FORMAT Text format]
 * @type {Object}
 */
_.TEXT_FORMAT = {
  TXT_NORMAL: [0x1b, 0x21, 0x00], // Normal text
  TXT_2HEIGHT: [0x1b, 0x21, 0x10], // Double height text 两倍高度的文本
  TXT_2WIDTH: [0x1b, 0x21, 0x20], // Double width text 双宽度的文本
  TXT_4SQUARE: [0x1b, 0x21, 0x30], // Double width & height text 双宽度和高度文本

  TXT_UNDERL_OFF: [0x1b, 0x2d, 0x00], // Underline font OFF 
  TXT_UNDERL_ON: [0x1b, 0x2d, 0x01], // Underline font 1-dot ON
  TXT_UNDERL2_ON: [0x1b, 0x2d, 0x02], // Underline font 2-dot ON
  TXT_BOLD_OFF: [0x1b, 0x45, 0x00], // Bold font OFF
  TXT_BOLD_ON: [0x1b, 0x45, 0x01], // Bold font ON
  TXT_ITALIC_OFF: [0x1b, 0x35], // Italic font ON
  TXT_ITALIC_ON: [0x1b, 0x34], // Italic font ON

  TXT_FONT_A: [0x1b, 0x4d, 0x00], // Font type A
  TXT_FONT_B: [0x1b, 0x4d, 0x01], // Font type B
  TXT_FONT_C: [0x1b, 0x4d, 0x02], // Font type C

  TXT_ALIGN_LT: [0x1b, 0x61, 0x00], // Left justification
  TXT_ALIGN_CT: [0x1b, 0x61, 0x01], // Centering
  TXT_ALIGN_RT: [0x1b, 0x61, 0x02], // Right justification
};

/**
 * [BARCODE_FORMAT Barcode format]
 * @type {Object}
 */
_.BARCODE_FORMAT = {
  BARCODE_TXT_OFF: [0x1d, 0x48, 0x00], // HRI barcode chars OFF
  BARCODE_TXT_ABV: [0x1d, 0x48, 0x01], // HRI barcode chars above
  BARCODE_TXT_BLW: [0x1d, 0x48, 0x02], // HRI barcode chars below
  BARCODE_TXT_BTH: [0x1d, 0x48, 0x03], // HRI barcode chars both above and below

  BARCODE_FONT_A: [0x1d, 0x66, 0x00], // Font type A for HRI barcode chars
  BARCODE_FONT_B: [0x1d, 0x66, 0x01], // Font type B for HRI barcode chars

  BARCODE_HEIGHT: function (height) { // Barcode Height [1-255]
    return [0x1d, 0x68, height];
  },
  BARCODE_WIDTH: function (width) {   // Barcode Width  [2-6]
    return [0x1d, 0x77, width];
  },
  BARCODE_HEIGHT_DEFAULT: [0x1d, 0x68, 0x64], // Barcode height default:100
  BARCODE_WIDTH_DEFAULT: [0x1d, 0x77, 0x01], // Barcode width default:1

  BARCODE_UPC_A: [0x1d, 0x6b, 0x00], // Barcode type UPC-A
  BARCODE_UPC_E: [0x1d, 0x6b, 0x01], // Barcode type UPC-E
  BARCODE_EAN13: [0x1d, 0x6b, 0x02], // Barcode type EAN13
  BARCODE_EAN8: [0x1d, 0x6b, 0x03], // Barcode type EAN8
  BARCODE_CODE39: [0x1d, 0x6b, 0x04], // Barcode type CODE39
  BARCODE_ITF: [0x1d, 0x6b, 0x05], // Barcode type ITF
  BARCODE_NW7: [0x1d, 0x6b, 0x06], // Barcode type NW7
  BARCODE_CODE93: [0x1d, 0x6b, 0x48], // Barcode type CODE93
  BARCODE_CODE128: [0x1d, 0x6b, 0x49], // Barcode type CODE128
};

/**
 * [IMAGE_FORMAT Image format]
 * @type {Object}
 */
_.IMAGE_FORMAT = {
  S_RASTER_N: [0x1d, 0x76, 0x30, 0x00], // Set raster image normal size
  S_RASTER_2W: [0x1d, 0x76, 0x30, 0x01], // Set raster image double width
  S_RASTER_2H: [0x1d, 0x76, 0x30, 0x02], // Set raster image double height
  S_RASTER_Q: [0x1d, 0x76, 0x30, 0x03], // Set raster image quadruple
};

/**
 * [BITMAP_FORMAT description]
 * @type {Object}
 */
_.BITMAP_FORMAT = {
  BITMAP_S8: [0x1b, 0x2a, 0x00],
  BITMAP_D8: [0x1b, 0x2a, 0x01],
  BITMAP_S24: [0x1b, 0x2a, 0x20],
  BITMAP_D24: [0x1b, 0x2a, 0x21]
};

/**
 * [GSV0_FORMAT description]
 * @type {Object}
 */
_.GSV0_FORMAT = {
  GSV0_NORMAL: [0x1d, 0x76, 0x30, 0x00],
  GSV0_DW: [0x1d, 0x76, 0x30, 0x01],
  GSV0_DH: [0x1d, 0x76, 0x30, 0x02],
  GSV0_DWDH: [0x1d, 0x76, 0x30, 0x03]
};

/**
 * [BEEP description]
 * @type {string}
 */
_.BEEP = [0x1b, 0x42]; // Printer Buzzer pre hex

/**
 * [COLOR description]
 * @type {Object}
 */

_.COLOR = {
  0: [0x1b, 0x72, 0x00], // black
  1: [0x1b, 0x72, 0x01] // red
};

/**
 * [exports description]
 * @type {[type]}
 */
module.exports = _;

注：
1、连接的蓝牙必须是低功耗的蓝牙，经典蓝牙无法搜索到（因为不能执行uni.onBluetoothDeviceFound）
2、部分手机需要将定位打开才能搜索到蓝牙（开启定位才能执行uni.onBluetoothDeviceFound）