• 记录--uni-app实现蓝牙打印小票

    这里给大家分享我在网上总结出来的一些知识，希望对大家有所帮助

    说明

    基于uni-app开发，调用官方蓝牙相关api实现连接蓝牙与向蓝牙热敏打印机发送字节流，可打印文字，二维码，图片，调整字体大小等，本文提供大概思路

    结构

    image.png

    • bluetooth.js 蓝牙连接相关模块封装
    • commands.js 打印十六进制相关代码库
    • gbk.js 编码转换库地址
    • printerjobs.js 打印实现库

    bluetooth.js

    蓝牙连接相关封装代码

    1. class Bluetooth {
    2.  
    3.     constructor() {
    4.         this.isOpenBle = false;
    5.         this.deviceId = "";
    6.         this.serviceId = "";
    7.         this.writeId = "";
    8.         this.notifyId = "";
    9.         this.BluetoothConnectStatus = false this.printStatus = false this.init()
    10.     }
    11.     init() {
    12.         this.closeBluetoothAdapter().then(() = >{
    13.             console.log("init初始关闭蓝牙模块") this.openBluetoothAdapter().then(() = >{
    14.                 console.log("init初始化蓝牙模块") this.reconnect() //自动连接蓝牙设备
    15.             })
    16.  
    17.         })
    18.     }
    19.  
    20.     showToast(title) {
    21.         uni.showToast({
    22.             title: title,
    23.             icon: 'none',
    24.             'duration': 2000
    25.         });
    26.     }
    27.  
    28.     openBluetoothAdapter() {
    29.         return new Promise((resolve, reject) = >{
    30.             uni.openBluetoothAdapter({
    31.                 success: res = >{
    32.                     this.isOpenBle = true;
    33.                     resolve(res);
    34.                 },
    35.                 fail: err = >{
    36.                     this.showToast(`蓝牙未打开`);
    37.                     reject(err);
    38.                 },
    39.             });
    40.         });
    41.  
    42.     }
    43.  
    44.     startBluetoothDevicesDiscovery() {
    45.         if (!this.isOpenBle) {
    46.             this.showToast(`初始化蓝牙模块失败`) return;
    47.         }
    48.  
    49.         let self = this;
    50.         uni.showLoading({
    51.             title: '蓝牙搜索中'
    52.         }) return new Promise((resolve, reject) = >{
    53.             setTimeout(() = >{
    54.                 uni.startBluetoothDevicesDiscovery({
    55.                     success: res = >{
    56.                         resolve(res)
    57.                     },
    58.                     fail: res = >{
    59.                         self.showToast(`搜索设备失败` + JSON.stringify(err));
    60.                         reject(err);
    61.                     }
    62.                 })
    63.             },
    64.             300);
    65.         });
    66.     }
    67.  
    68.     stopBluetoothDevicesDiscovery() {
    69.         let self = this;
    70.         return new Promise((resolve, reject) = >{
    71.             uni.stopBluetoothDevicesDiscovery({
    72.                 success: e = >{
    73.                     uni.hideLoading();
    74.                 },
    75.                 fail: e = >{
    76.                     uni.hideLoading();
    77.                     self.showToast(`停止搜索蓝牙设备失败` + JSON.stringify(err));
    78.                 }
    79.             })
    80.         });
    81.     }
    82.  
    83.     createBLEConnection() {
    84.         //设备deviceId
    85.         let deviceId = this.deviceId;
    86.         let self = this;
    87.  
    88.         // uni.showLoading({
    89.         // 	mask: true,
    90.         // 	title: '设别连接中,请稍候...'
    91.         // })
    92.         console.log(this.deviceId);
    93.         return new Promise((resolve, reject) = >{
    94.             uni.createBLEConnection({
    95.                 deviceId,
    96.                 success: (res) = >{
    97.                     console.log("res:createBLEConnection " + JSON.stringify(res));
    98.                     resolve(res)
    99.                 },
    100.                 fail: err = >{
    101.                     uni.hideLoading();
    102.                     self.showToast(`停止搜索蓝牙设备失败` + JSON.stringify(err));
    103.                     reject(err);
    104.                 }
    105.             })
    106.         });
    107.     }
    108.  
    109.     //获取蓝牙设备所有服务(service)
    110.     getBLEDeviceServices() {
    111.         let _serviceList = [];
    112.         let deviceId = this.deviceId;
    113.         let self = this;
    114.  
    115.         return new Promise((resolve, reject) = >{
    116.             setTimeout(() = >{
    117.                 uni.getBLEDeviceServices({
    118.                     deviceId,
    119.                     success: res = >{
    120.                         for (let service of res.services) {
    121.                             if (service.isPrimary) {
    122.                                 _serviceList.push(service);
    123.                             }
    124.                         }
    125.                         uni.hideLoading();
    126.                         console.log("_serviceList: " + JSON.stringify(_serviceList));
    127.                         resolve(_serviceList)
    128.                     },
    129.                     fail: err = >{
    130.                         uni.hideLoading();
    131.                         // self.showToast(`获取设备Services` + JSON.stringify(err));
    132.                         reject(err);
    133.                     },
    134.                 })
    135.             },
    136.             500);
    137.         });
    138.     }
    139.  
    140.     //获取蓝牙设备某个服务中所有特征值(characteristic)
    141.     getBLEDeviceCharacteristics() {
    142.         // console.log("getBLEDeviceCharacteristics")
    143.         let deviceId = this.deviceId;
    144.         let serviceId = this.serviceId;
    145.  
    146.         let self = this;
    147.         return new Promise((resolve, reject) = >{
    148.             uni.getBLEDeviceCharacteristics({
    149.                 deviceId,
    150.                 serviceId,
    151.                 success: res = >{
    152.                     for (let _obj of res.characteristics) {
    153.                         //获取notify
    154.                         if (_obj.properties.notify) {
    155.                             self.notifyId = _obj.uuid;
    156.                             uni.setStorageSync('notifyId', self.notifyId);
    157.                         }
    158.                         //获取writeId
    159.                         if (_obj.properties.write) {
    160.                             self.writeId = _obj.uuid;
    161.                             uni.setStorageSync('writeId', self.writeId);
    162.                         }
    163.                     }
    164.  
    165.                     //console.log("res:getBLEDeviceCharacteristics " + JSON.stringify(res));
    166.                     let result = {
    167.                         'notifyId': self.notifyId,
    168.                         'writeId': self.writeId
    169.                     };
    170.                     // self.showToast(`获取服务中所有特征值OK,${JSON.stringify(result)}`);
    171.                     this.BluetoothStatus = true resolve(result)
    172.                 },
    173.                 fail: err = >{
    174.                     self.showToast(`getBLEDeviceCharacteristics` + JSON.stringify(err));
    175.                     reject(err);
    176.                 }
    177.             })
    178.         });
    179.     }
    180.  
    181.     //断开联链接
    182.     closeBLEConnection() {
    183.         let deviceId = this.deviceId;
    184.         uni.closeBLEConnection({
    185.             deviceId,
    186.             success(res) {
    187.                 console.log("closeBLEConnection" + res)
    188.             }
    189.         })
    190.     }
    191.  
    192.     notifyBLECharacteristicValue() {
    193.         let deviceId = this.deviceId;
    194.         let serviceId = this.serviceId;
    195.         let characteristicId = this.notifyId;
    196.  
    197.         uni.notifyBLECharacteristicValueChange({
    198.             state: true,
    199.             // 启用 notify 功能
    200.             deviceId,
    201.             serviceId,
    202.             characteristicId,
    203.             success(res) {
    204.                 uni.onBLECharacteristicValueChange(function(res) {
    205.                     console.log('onBLECharacteristicValueChange', res);
    206.                 });
    207.             },
    208.             fail(res) {
    209.                 console.log('notifyBLECharacteristicValueChange failed:' + res.errMsg);
    210.  
    211.             }
    212.         });
    213.     }
    214.  
    215.     writeBLECharacteristicValue(buffer) {
    216.         let deviceId = this.deviceId;
    217.         let serviceId = this.serviceId;
    218.         let characteristicId = this.writeId;
    219.  
    220.         // console.log(deviceId);
    221.         // console.log(serviceId);
    222.         // console.log(characteristicId);
    223.         return new Promise((resolve, reject) = >{
    224.             uni.writeBLECharacteristicValue({
    225.                 deviceId,
    226.                 serviceId,
    227.                 characteristicId,
    228.                 value: buffer,
    229.                 success(res) {
    230.                     // console.log('message发送成功', JSON.stringify(res));
    231.                     resolve(res);
    232.                 },
    233.                 fail(err) {
    234.                     // console.log('message发送失败', JSON.stringify(err));
    235.                     reject(err);
    236.                 }
    237.             });
    238.         });
    239.     }
    240.  
    241.     closeBluetoothAdapter() {
    242.         return new Promise((resolve, reject) = >{
    243.             uni.closeBluetoothAdapter({
    244.                 success: res = >{
    245.                     resolve()
    246.                 }
    247.             });
    248.         })
    249.  
    250.     }
    251.  
    252.     //若APP在之前已有搜索过某个蓝牙设备，并成功建立连接，可直接传入之前搜索获取的 deviceId 直接尝试连接该设备，无需进行搜索操作。
    253.     reconnect() { (async() = >{
    254.             try {
    255.                 this.deviceId = this.deviceId || uni.getStorageSync("deviceId");
    256.                 this.serviceId = this.serviceId || uni.getStorageSync("serviceId");
    257.                 console.log("this.deviceId", this.deviceId) console.log("this.serviceId", this.serviceId) let result1 = await this.createBLEConnection();
    258.                 console.log("createBLEConnection: " + JSON.stringify(result1));
    259.  
    260.                 let result2 = await this.getBLEDeviceServices();
    261.                 console.log("getBLEDeviceServices: " + JSON.stringify(result2));
    262.  
    263.                 let result3 = await this.getBLEDeviceCharacteristics();
    264.                 console.log("getBLEDeviceCharacteristics: " + JSON.stringify(result3));
    265.                 this.BluetoothConnectStatus = true this.showToast("蓝牙打印设备连接成功")
    266.                 // this.writeId = uni.getStorageSync("writeId");
    267.                 // this.notifyId = uni.getStorageSync("notifyId");
    268.             } catch(err) {
    269.                 console.log("err: " + err);
    270.                 // this.showToast("蓝牙打印设备连接失败")
    271.             }
    272.  
    273.         })();
    274.     }
    275. }
    276.  
    277. export
    278. default Bluetooth;

    commands.js

    打印机ESC/POS十六进制编码库

    1. /**
    2.  * 修改自https://github.com/song940/node-escpos/blob/master/commands.js
    3.  * ESC/POS _ (Constants)
    4.  */
    5. var _ = {
    6.   LF: [0x0a],
    7.   FS: [0x1c],
    8.   FF: [0x0c],
    9.   GS: [0x1d],
    10.   DLE: [0x10],
    11.   EOT: [0x04],
    12.   NUL: [0x00],
    13.   ESC: [0x1b],
    14.   EOL: '\n',
    15. };
    16.  
    17. /**
    18.  * [FEED_CONTROL_SEQUENCES Feed control sequences]
    19.  * @type {Object}
    20.  */
    21. _.FEED_CONTROL_SEQUENCES = {
    22.   CTL_LF: [0x0a],   // Print and line feed
    23.   CTL_GLF: [0x4a, 0x00],   // Print and feed paper (without spaces between lines)
    24.   CTL_FF: [0x0c],   // Form feed
    25.   CTL_CR: [0x0d],   // Carriage return
    26.   CTL_HT: [0x09],   // Horizontal tab
    27.   CTL_VT: [0x0b],   // Vertical tab
    28. };
    29.  
    30. _.CHARACTER_SPACING = {
    31.   CS_DEFAULT: [0x1b, 0x20, 0x00],
    32.   CS_SET: [0x1b, 0x20]
    33. };
    34.  
    35. _.LINE_SPACING = {
    36.   LS_DEFAULT: [0x1b, 0x32],
    37.   LS_SET: [0x1b, 0x33]
    38. };
    39.  
    40. /**
    41.  * [HARDWARE Printer hardware]
    42.  * @type {Object}
    43.  */
    44. _.HARDWARE = {
    45.   HW_INIT: [0x1b, 0x40], // Clear data in buffer and reset modes
    46.   HW_SELECT: [0x1b, 0x3d, 0x01], // Printer select
    47.   HW_RESET: [0x1b, 0x3f, 0x0a, 0x00], // Reset printer hardware
    48.   Print:[0x1b, 0x64,0x01] //Print and feed paper
    49. };
    50.  
    51. /**
    52.  * [CASH_DRAWER Cash Drawer]
    53.  * @type {Object}
    54.  */
    55. _.CASH_DRAWER = {
    56.   CD_KICK_2: [0x1b, 0x70, 0x00], // Sends a pulse to pin 2 []
    57.   CD_KICK_5: [0x1b, 0x70, 0x01], // Sends a pulse to pin 5 []
    58. };
    59.  
    60. /**
    61.  * [MARGINS Margins sizes]
    62.  * @type {Object}
    63.  */
    64. _.MARGINS = {
    65.   BOTTOM: [0x1b, 0x4f], // Fix bottom size
    66.   LEFT: [0x1b, 0x6c], // Fix left size
    67.   RIGHT: [0x1b, 0x51], // Fix right size
    68. };
    69.  
    70. /**
    71.  * [PAPER Paper]
    72.  * @type {Object}
    73.  */
    74. _.PAPER = {
    75.   PAPER_FULL_CUT: [0x1d, 0x56, 0x00], // Full cut paper
    76.   PAPER_PART_CUT: [0x1d, 0x56, 0x01], // Partial cut paper
    77.   PAPER_CUT_A: [0x1d, 0x56, 0x41], // Partial cut paper
    78.   PAPER_CUT_B: [0x1d, 0x56, 0x42], // Partial cut paper
    79. };
    80.  
    81. /**
    82.  * [TEXT_FORMAT Text format]
    83.  * @type {Object}
    84.  */
    85. _.TEXT_FORMAT = {
    86.   TXT_NORMAL: [0x1b, 0x21, 0x00], // Normal text
    87.   TXT_2HEIGHT: [0x1b, 0x21, 0x10], // Double height text
    88.   TXT_2WIDTH: [0x1b, 0x21, 0x20], // Double width text
    89.   TXT_4SQUARE: [0x1b, 0x21, 0x30], // Double width & height text
    90.  
    91.   TXT_UNDERL_OFF: [0x1b, 0x2d, 0x00], // Underline font OFF
    92.   TXT_UNDERL_ON: [0x1b, 0x2d, 0x01], // Underline font 1-dot ON
    93.   TXT_UNDERL2_ON: [0x1b, 0x2d, 0x02], // Underline font 2-dot ON
    94.   TXT_BOLD_OFF: [0x1b, 0x45, 0x00], // Bold font OFF
    95.   TXT_BOLD_ON: [0x1b, 0x45, 0x01], // Bold font ON
    96.   TXT_ITALIC_OFF: [0x1b, 0x35], // Italic font ON
    97.   TXT_ITALIC_ON: [0x1b, 0x34], // Italic font ON
    98.  
    99.   TXT_FONT_A: [0x1b, 0x4d, 0x00], // Font type A
    100.   TXT_FONT_B: [0x1b, 0x4d, 0x01], // Font type B
    101.   TXT_FONT_C: [0x1b, 0x4d, 0x02], // Font type C
    102.  
    103.   TXT_ALIGN_LT: [0x1b, 0x61, 0x00], // Left justification
    104.   TXT_ALIGN_CT: [0x1b, 0x61, 0x01], // Centering
    105.   TXT_ALIGN_RT: [0x1b, 0x61, 0x02], // Right justification
    106. };
    107.  
    108. /**
    109.  * [BARCODE_FORMAT Barcode format]
    110.  * @type {Object}
    111.  */
    112. _.BARCODE_FORMAT = {
    113.   BARCODE_TXT_OFF: [0x1d, 0x48, 0x00], // HRI barcode chars OFF
    114.   BARCODE_TXT_ABV: [0x1d, 0x48, 0x01], // HRI barcode chars above
    115.   BARCODE_TXT_BLW: [0x1d, 0x48, 0x02], // HRI barcode chars below
    116.   BARCODE_TXT_BTH: [0x1d, 0x48, 0x03], // HRI barcode chars both above and below
    117.  
    118.   BARCODE_FONT_A: [0x1d, 0x66, 0x00], // Font type A for HRI barcode chars
    119.   BARCODE_FONT_B: [0x1d, 0x66, 0x01], // Font type B for HRI barcode chars
    120.  
    121.   BARCODE_HEIGHT: function (height) { // Barcode Height [1-255]
    122.     return [0x1d, 0x68, height];
    123.   },
    124.   BARCODE_WIDTH: function (width) {   // Barcode Width  [2-6]
    125.     return [0x1d, 0x77, width];
    126.   },
    127.   BARCODE_HEIGHT_DEFAULT: [0x1d, 0x68, 0x64], // Barcode height default:100
    128.   BARCODE_WIDTH_DEFAULT: [0x1d, 0x77, 0x01], // Barcode width default:1
    129.  
    130.   BARCODE_UPC_A: [0x1d, 0x6b, 0x00], // Barcode type UPC-A
    131.   BARCODE_UPC_E: [0x1d, 0x6b, 0x01], // Barcode type UPC-E
    132.   BARCODE_EAN13: [0x1d, 0x6b, 0x02], // Barcode type EAN13
    133.   BARCODE_EAN8: [0x1d, 0x6b, 0x03], // Barcode type EAN8
    134.   BARCODE_CODE39: [0x1d, 0x6b, 0x04], // Barcode type CODE39
    135.   BARCODE_ITF: [0x1d, 0x6b, 0x05], // Barcode type ITF
    136.   BARCODE_NW7: [0x1d, 0x6b, 0x06], // Barcode type NW7
    137.   BARCODE_CODE93: [0x1d, 0x6b, 0x48], // Barcode type CODE93
    138.   BARCODE_CODE128: [0x1d, 0x6b, 0x49], // Barcode type CODE128
    139. };
    140.  
    141. /**
    142.  * [IMAGE_FORMAT Image format]
    143.  * @type {Object}
    144.  */
    145. _.IMAGE_FORMAT = {
    146.   S_RASTER_N: [0x1d, 0x76, 0x30, 0x00], // Set raster image normal size
    147.   S_RASTER_2W: [0x1d, 0x76, 0x30, 0x01], // Set raster image double width
    148.   S_RASTER_2H: [0x1d, 0x76, 0x30, 0x02], // Set raster image double height
    149.   S_RASTER_Q: [0x1d, 0x76, 0x30, 0x03], // Set raster image quadruple
    150. };
    151.  
    152. /**
    153.  * [BITMAP_FORMAT description]
    154.  * @type {Object}
    155.  */
    156. _.BITMAP_FORMAT = {
    157.   BITMAP_S8: [0x1b, 0x2a, 0x00],
    158.   BITMAP_D8: [0x1b, 0x2a, 0x01],
    159.   BITMAP_S24: [0x1b, 0x2a, 0x20],
    160.   BITMAP_D24: [0x1b, 0x2a, 0x21]
    161. };
    162.  
    163. /**
    164.  * [GSV0_FORMAT description]
    165.  * @type {Object}
    166.  */
    167. _.GSV0_FORMAT = {
    168.   GSV0_NORMAL: [0x1d, 0x76, 0x30, 0x00],
    169.   GSV0_DW: [0x1d, 0x76, 0x30, 0x01],
    170.   GSV0_DH: [0x1d, 0x76, 0x30, 0x02],
    171.   GSV0_DWDH: [0x1d, 0x76, 0x30, 0x03]
    172. };
    173.  
    174. /**
    175.  * [BEEP description]
    176.  * @type {string}
    177.  */
    178. _.BEEP = [0x1b, 0x42]; // Printer Buzzer pre hex
    179.  
    180. /**
    181.  * [COLOR description]
    182.  * @type {Object}
    183.  */
    185. _.COLOR = {
    186.   0: [0x1b, 0x72, 0x00], // black
    187.   1: [0x1b, 0x72, 0x01] // red
    188. };
    189.  
    190. /**
    191.  * [exports description]
    192.  * @type {[type]}
    193.  */
    194. module.exports = _;

    printerjobs.js

    1. const commands = require('./commands');
    2. const gbk = require('./gbk');
    3.  
    4. const printerJobs = function() {
    5. 	this._queue = Array.from(commands.HARDWARE.HW_INIT);
    6. 	this._enqueue = function(cmd) {
    7. 		this._queue.push.apply(this._queue, cmd);
    8. 	}
    9. };
    10.  
    11. /**
    12.  * 增加打印内容
    13.  * @param  {string} content  文字内容
    14.  */
    15. printerJobs.prototype.text = function(content) {
    16. 	if (content) {
    17. 		let uint8Array = gbk.encode(content);
    18. 		let encoded = Array.from(uint8Array);
    19. 		this._enqueue(encoded);
    20. 	}
    21. 	return this;
    22. };
    23.  
    24. /**
    25.  * 打印文字
    26.  * @param  {string} content  文字内容
    27.  */
    28. printerJobs.prototype.print = function(content) {
    29. 	this.text(content);
    30. 	// this._enqueue(commands.LF);
    31. 	return this;
    32. };
    33. printerJobs.prototype.printL = function(content) {
    34. 	this.text(content);
    35. 	this._enqueue(commands.LF);
    36. 	return this;
    37. };
    38.  
    39. printerJobs.prototype.printImage = function(content) {
    40.  
    41. 	if (content) {
    42. 		const cmds = [].concat([29, 118, 48, 0], content);
    43. 		// console.log("cmds",cmds)
    44. 		this._enqueue(cmds);
    45. 		this._enqueue(commands.LF);
    46. 	}
    47.  
    48. 	return this;
    49. };
    50.  
    51.  
    52. /**
    53.  * 打印文字并换行
    54.  * @param  {string}  content  文字内容
    55.  */
    56. printerJobs.prototype.println = function(content = '') {
    57. 	return this.print(content + commands.EOL);
    58. };
    59.  
    60. /**
    61.  * 设置对齐方式
    62.  * @param {string} align 对齐方式 LT/CT/RT
    63.  */
    64. printerJobs.prototype.setAlign = function(align) {
    65. 	this._enqueue(commands.TEXT_FORMAT['TXT_ALIGN_' + align.toUpperCase()]);
    66. 	return this;
    67. };
    68.  
    69. /**
    70.  * 设置字体
    71.  * @param  {string} family A/B/C
    72.  */
    73. printerJobs.prototype.setFont = function(family) {
    74. 	this._enqueue(commands.TEXT_FORMAT['TXT_FONT_' + family.toUpperCase()]);
    75. 	return this;
    76. };
    77.  
    78. /**
    79.  * 设定字体尺寸
    80.  * @param  {number} width 字体宽度 1~2
    81.  * @param  {number} height 字体高度 1~2
    82.  */
    83. printerJobs.prototype.setSize = function(width, height) {
    84. 	if (2 >= width && 2 >= height) {
    85. 		this._enqueue(commands.TEXT_FORMAT.TXT_NORMAL);
    86. 		if (2 === width && 2 === height) {
    87. 			this._enqueue(commands.TEXT_FORMAT.TXT_4SQUARE);
    88. 		} else if (1 === width && 2 === height) {
    89. 			this._enqueue(commands.TEXT_FORMAT.TXT_2HEIGHT);
    90. 		} else if (2 === width && 1 === height) {
    91. 			this._enqueue(commands.TEXT_FORMAT.TXT_2WIDTH);
    92. 		}
    93. 	}
    94. 	return this;
    95. };
    96.  
    97. /**
    98.  * 设定字体是否加粗
    99.  * @param  {boolean} bold
    100.  */
    101. printerJobs.prototype.setBold = function(bold) {
    102. 	if (typeof bold !== 'boolean') {
    103. 		bold = true;
    104. 	}
    105. 	this._enqueue(bold ? commands.TEXT_FORMAT.TXT_BOLD_ON : commands.TEXT_FORMAT.TXT_BOLD_OFF);
    106. 	return this;
    107. };
    108.  
    109. /**
    110.  * 设定是否开启下划线
    111.  * @param  {boolean} underline
    112.  */
    113. printerJobs.prototype.setUnderline = function(underline) {
    114. 	if (typeof underline !== 'boolean') {
    115. 		underline = true;
    116. 	}
    117. 	this._enqueue(underline ? commands.TEXT_FORMAT.TXT_UNDERL_ON : commands.TEXT_FORMAT.TXT_UNDERL_OFF);
    118. 	return this;
    119. };
    120.  
    121. /**
    122.  * 设置行间距为 n 点行,默认值行间距是 30 点
    123.  * @param {number} n 0≤n≤255
    124.  */
    125. printerJobs.prototype.setLineSpacing = function(n) {
    126. 	if (n === undefined || n === null) {
    127. 		this._enqueue(commands.LINE_SPACING.LS_DEFAULT);
    128. 	} else {
    129. 		this._enqueue(commands.LINE_SPACING.LS_SET);
    130. 		this._enqueue([n]);
    131. 	}
    132. 	return this;
    133. };
    134.  
    135. /**
    136.  * 打印空行
    137.  * @param {number} n
    138.  */
    139. printerJobs.prototype.lineFeed = function(n = 1) {
    140. 	return this.print(new Array(n).fill(commands.EOL).join(''));
    141. };
    142.  
    143. /**
    144.  *  设置字体颜色，需要打印机支持
    145.  *  @param  {number} color - 0 默认颜色黑色 1 红色
    146.  */
    147. printerJobs.prototype.setColor = function(color) {
    148. 	this._enqueue(commands.COLOR[color === 1 ? 1 : 0]);
    149. 	return this;
    150. };
    151.  
    152. /**
    153.  * https://support.loyverse.com/hardware/printers/use-the-beeper-in-a-escpos-printers
    154.  * 蜂鸣警报，需要打印机支持
    155.  * @param  {number} n    蜂鸣次数,1-9
    156.  * @param  {number} t 蜂鸣长短,1-9
    157.  */
    158. printerJobs.prototype.beep = function(n, t) {
    159. 	this._enqueue(commands.BEEP);
    160. 	this._enqueue([n, t]);
    161. 	return this;
    162. };
    163.  
    164. /**
    165.  * 清空任务
    166.  */
    167. printerJobs.prototype.clear = function() {
    168. 	this._queue = Array.from(commands.HARDWARE.HW_RESET);
    169. 	// this._enqueue(commands.HARDWARE.Print);
    170. 	return this;
    171. };
    172.  
    173. /**
    174.  * 返回ArrayBuffer
    175.  */
    176. printerJobs.prototype.buffer = function() {
    177. 	return new Uint8Array(this._queue).buffer;
    178. };
    179.  
    180. module.exports = printerJobs;

    代码实现

    封装蓝牙连接，搜索，断开相关操作模块

    蓝牙搜索

    1. startBluetoothDeviceDiscovery() {
    2.     let self = this;
    3.     self.tempDeviceList = [];
    4.  
    5.     uni.startBluetoothDevicesDiscovery({
    6.         success: res = >{
    7.             uni.onBluetoothDeviceFound(devices = >{
    8.                 // console.log("发现设备: " + JSON.stringify(devices));
    9.                 if (!self.tempDeviceList.some(item = >{
    10.                     return item.deviceId === devices.devices[0].deviceId || item.name === devices.devices[0].name
    11.                 })) {
    12.                     // console.log("new", devices.devices)
    13.                     self.tempDeviceList.push(devices.devices[0])
    14.                 }
    15.             });
    16.  
    17.             this.connect = false this.$refs.popup.open()
    18.         },
    19.         fail: err = >{
    20.             uni.showToast({
    21.                 title: '搜索设备失败' + JSON.stringify(err),
    22.                 icon: 'none'
    23.             })
    24.         }
    25.     })
    26. },

    搜索完成选择设备

    1. async select_deviceId(item) {
    2.     this.deviceId = item.deviceId;
    3.     this.$bluetooth.deviceId = item.deviceId;
    4.     uni.setStorageSync('deviceId', this.$bluetooth.deviceId);
    5.     this.serviceList = [];
    6.  
    7.     try {
    8.         //1.链接设备
    9.         let result = await this.$bluetooth.createBLEConnection();
    10.         //2.寻找服务
    11.         let result2 = null setTimeout(async() = >{
    12.             result2 = await this.$bluetooth.getBLEDeviceServices();
    13.             console.log("获取服务: " + JSON.stringify(result2));
    14.             this.serviceList = result2;
    15.  
    16.             console.log("serviceList", this.serviceList.length)
    17.  
    18.             if (this.serviceList[2].uuid) {
    19.                 this.select_service(this.serviceList[2].uuid)
    20.             } else {
    21.                 uni.showToast({
    22.                     title: '不是打印设备',
    23.                     icon: 'none'
    24.                 })
    25.             }
    26.  
    27.         },
    28.         1000)
    29.  
    30.     } catch(e) {
    31.         //TODO handle the exception
    32.         console.log("e: " + JSON.stringify(e));
    33.     }
    34. },

    选中服务

    1. async select_service(res) {
    2.     console.log("select_service", res)
    3.  
    4.     this.$bluetooth.serviceId = res;
    5.     console.log("this.$bluetooth.serviceId", this.$bluetooth.serviceId) uni.setStorageSync('serviceId', res);
    6.  
    7.     try {
    8.         let result = await this.$bluetooth.getBLEDeviceCharacteristics();
    9.         console.log("resultresult", result) this.$refs.popup.close()
    10.  
    11.         uni.showToast({
    12.             title: "连接成功"
    13.         })
    14.         // this.pickUpOnce()
    15.     } catch(e) {
    16.         //TODO handle the exception
    17.         console.log("e: " + JSON.stringify(e));
    18.     }
    19. },

    打印内容组合

    1. async writeBLECharacteristicValueTongzhishu() {
    2. 	let Qrcode_res = await this.get_Qrcode()
    3. 	let sign = await this.getSign()
    4. 	console.log("sign")
    5. 	let printerJobs = new PrinterJobs()
    6. 	let p = printerJobs.setAlign('ct')
    7. 		.setBold(true)
    8. 		.printL("打印测试")
    9.  
    10. 	let buffer = printerJobs.buffer();
    11. 	this.printbuffs(buffer);
    12. },

    打印内容组合

    主要是实现打印编码推送循环，手机蓝牙可能出现编码发送失败情况，这个时候就是要循环保证每个字节准确推送

    1. printbuffs(buffer, fun) {
    2.     console.log("printbuffs", buffer.byteLength) const maxChunk = 8;
    3.     let p = Promise.resolve();
    4.     for (let i = 0, j = 0, length = buffer.byteLength; i < length; i += maxChunk, j++) {
    5.         let subPackage = buffer.slice(i, i + maxChunk <= length ? (i + maxChunk) : length);
    6.         p = p.then(() = >{
    7.             if (i == 0) {
    8.                 this.$bluetooth.printStatus = true this.$refs.loading.open();
    9.  
    10.             }
    11.             if ((i + maxChunk) >= length) {
    12.                 console.log("printEnd")
    13.  
    14.                 setTimeout(() = >{
    15.                     this.$bluetooth.printStatus = false this.$refs.loading.close();
    16.                 },
    17.                 1000)
    18.             }
    19.             return this.printbuff(subPackage)
    20.         })
    21.     }
    22.     p = p.then(() = >{
    23.         console.log("printEve") fun()
    24.     })
    25.  
    26. },
    27. async printbuff(buffer) {
    28.     while (true) {
    29.         try {
    30.             await this.$bluetooth.writeBLECharacteristicValue(buffer);
    31.             break;
    32.         } catch(e) {}
    33.     }
    34. },

    本文转载于:

    https://juejin.cn/post/7001752261722537991

    如果对您有所帮助，欢迎您点个关注，我会定时更新技术文档，大家一起讨论学习，一起进步。

     

  • 相关阅读:
    BP神经网络的梯度公式推导(三层结构)
    C语言 —— 函数栈帧的创建和销毁
    Java项目：ssm汽车租赁系统
    java基础-并发编程-CountDownLatch（JDK1.8）源码学习
    想考PMP，符合报名条件么？怎么报考？
    使用pyQt5和matplotlib绘制图表
    【开发经验】客户端互踢实现思路
    【C语言】关键字的补充
    从GFS到GPT，AI Infra的激荡20年
    1003 - 编程求1+3+5+...+n
  • 原文地址：https://blog.csdn.net/qq_40716795/article/details/126837982