Hello! 欢迎来到阿珏酱のBlog！

与其想着怎么美丽地牺牲,倒不如想着怎么漂亮地活到最后一刻。

Single
折腾代码

热敏蓝牙打印机开发

avatar
阿珏 2019-11-05 3.22k
14 评论

最近在做小票打印这块，项目需求是IOS和安卓两种都要实现，开始做的时候也是一脸懵，然后网上找了不少资料，踩了一堆坑，看了好多文章，结果还好成了
蓝牙打印机一般分为两种打印模式，票据打印、标签打印

公司买的渣渣打印机连开发文档都没有，害我走了不少坑，让我开发买的时候也不咨询咨询我
目前微信小程序连接蓝牙打印机 wx.createBLEConnection 测试在IOS设备上没有问题，在部分安卓手机上会出现异常（表现为，连接是会弹出系统配对框，不管点取消还是输入配对码后点确定，都会立马断开连接。如果不输入也不取消则会在30秒以内自动断开蓝牙打印机）

现在采用的方式是各给安卓和IOS写一套蓝牙打印的命令
IOS

 复制代码
  1. // ====================蓝牙操作==================  //初始化蓝牙模块
  2. openBluetoothAdapter() {
  3.  
  4.     if (app.sysinfo.provider == 1) {
  5.         // 开启蓝牙
  6.         app.onBluetooth()
  7.         setTimeout(() => {
  8.             this.android_search()
  9.         }, 2000)
  10.         return false;
  11.     }
  12.  
  13.  
  14.     this.closeBluetoothAdapter()
  15.     uni.openBluetoothAdapter({
  16.         success: (res) => {
  17.             console.log("初始化蓝牙模块: " + JSON.stringify(res));
  18.             this.startBluetoothDevicesDiscovery()
  19.         },
  20.         fail: (res) => {
  21.             if (res.errCode === 10001) {
  22.                 uni.onBluetoothAdapterStateChange((res) => {
  23.                     console.log('监听蓝牙适配器状态变化事件', res)
  24.                     if (res.available == false) {
  25.                         app.global_printing = {}
  26.                         this.connected = false
  27.                         this.chs = []
  28.                         this.canWrite = false
  29.                     }
  30.                     if (res.available) {
  31.                         this.startBluetoothDevicesDiscovery()
  32.                     }
  33.                 })
  34.             }
  35.             if (res.errCode) {
  36.                 app.alert('初始化蓝牙失败，错误码：' + res.errCode)
  37.                 return false;
  38.             }
  39.             app.alert(res.errMsg)
  40.         }
  41.     })
  42. },
  43.  
  44. //获取本机蓝牙适配器状态
  45. getBluetoothAdapterState() {
  46.     uni.getBluetoothAdapterState({
  47.         success: (res) => {
  48.             console.log('获取本机蓝牙适配器状态。', JSON.stringify(res))
  49.             if (res.discovering) {
  50.                 this.onBluetoothDeviceFound()
  51.             } else if (res.available) {
  52.                 this.startBluetoothDevicesDiscovery()
  53.             }
  54.         },
  55.         fail: (res) => {
  56.             console.log('error:获取本机蓝牙适配器状态失败', JSON.stringify(res))
  57.             setTimeout(() => {
  58.                 this.getBluetoothAdapterState()
  59.             }, 500)
  60.         }
  61.     })
  62. },
  63.  
  64. //开始搜寻附近的蓝牙外围设备
  65. startBluetoothDevicesDiscovery() {
  66.     console.log(this.discoveryStarted);
  67.     if (this.discoveryStarted) {
  68.         return
  69.     }
  70.     console.log('开始搜索蓝牙设备');
  71.     this.discoveryStarted = true
  72.     this.onBluetoothDeviceFound()
  73.     setTimeout(() => {
  74.         uni.startBluetoothDevicesDiscovery({
  75.             allowDuplicatesKey: true,
  76.             success: (res) => {
  77.                 console.log('startBluetoothDevicesDiscovery success', JSON.stringify(
  78.                     res))
  79.             },
  80.             fail: (res) => {
  81.                 if (res.errCode == '10001') {
  82.                     app.alert('当前蓝牙适配器不可用')
  83.                 } else {
  84.                     app.alert('搜索蓝牙失败,状态码：' + res.errCode)
  85.                 }
  86.             }
  87.         })
  88.     }, 500)
  89.  
  90. },
  91.  
  92. // 停止搜索
  93. stopBluetoothDevicesDiscovery() {
  94.     uni.stopBluetoothDevicesDiscovery()
  95.     this.discoveryStarted = false
  96. },
  97.  
  98. //寻找到新设备的事件的回调函数
  99. onBluetoothDeviceFound() {
  100.     console.log('寻找到新设备的事件的回调函数');
  101.     uni.onBluetoothDeviceFound((res) => {
  102.         console.log(res);
  103.         res.devices.forEach(device => {
  104.             if (!device.name && !device.localName) {
  105.                 return
  106.             }
  107.             const foundDevices = this.devices
  108.             const idx = this.inArray(foundDevices, 'deviceId', device.deviceId)
  109.             if (idx === -1) {
  110.                 this.devices.push(device)
  111.             } else {
  112.                 this.devices[idx] = device
  113.             }
  114.  
  115.         })
  116.     })
  117. },
  118.  
  119.  
  120. //连接低功耗蓝牙设备
  121. createBLEConnection(e) {
  122.     uni.showLoading({
  123.         title: '设备连接中',
  124.         mask: true
  125.     });
  126.  
  127.     const ds = e.currentTarget.dataset
  128.     const deviceId = ds.deviceId
  129.     const name = ds.name
  130.  
  131.     if (app.sysinfo.provider == 1) {
  132.         if (ds.pair !== true) {
  133.             this.android_search(deviceId)
  134.         } else {
  135.             console.log('已配对')
  136.         }
  137.  
  138.         var device = null,
  139.             BAdapter = null,
  140.             BluetoothAdapter = null,
  141.             uuid = null,
  142.             main = null,
  143.             bluetoothSocket = null;
  144.  
  145.         var mac_address = deviceId
  146.  
  147.         var main = plus.android.runtimeMainActivity();
  148.         BluetoothAdapter = plus.android.importClass("android.bluetooth.BluetoothAdapter");
  149.         var UUID = plus.android.importClass("java.util.UUID");
  150.         uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
  151.         BAdapter = BluetoothAdapter.getDefaultAdapter();
  152.         device = BAdapter.getRemoteDevice(mac_address);
  153.         plus.android.importClass(device);
  154.         bluetoothSocket = device.createInsecureRfcommSocketToServiceRecord(uuid);
  155.         plus.android.importClass(bluetoothSocket);
  156.  
  157.         if (!bluetoothSocket.isConnected()) {
  158.             console.log('检测到设备未连接，尝试连接....');
  159.             bluetoothSocket.connect();
  160.         }
  161.  
  162.         this.connected = true
  163.         this.name = name
  164.         this.deviceId = deviceId
  165.         this.canWrite = true
  166.         app.global_printing = {
  167.             name: name,
  168.             deviceId: deviceId
  169.         }
  170.  
  171.         app.saveData1('global_printing', app.global_printing)
  172.  
  173.         uni.hideLoading();
  174.         return false;
  175.     }
  176.  
  177.     uni.createBLEConnection({
  178.         deviceId,
  179.         success: (res) => {
  180.             this.connected = true
  181.             this.name = name
  182.             this.deviceId = deviceId
  183.             app.global_printing = {
  184.                 name: name,
  185.                 deviceId: deviceId
  186.             }
  187.             this.onBLEConnectionStateChange()
  188.             // 防止获取失败
  189.             setTimeout(() => {
  190.                 this.getBLEDeviceServices(deviceId)
  191.             }, 1000)
  192.         },
  193.         fail: (res) => {
  194.             uni.hideLoading();
  195.             app.Toast('设备连接失败')
  196.             console.log("蓝牙连接失败:", res);
  197.         }
  198.     })
  199.     this.stopBluetoothDevicesDiscovery()
  200. },
  201.  
  202. //获取蓝牙设备所有服务(service)
  203. getBLEDeviceServices(deviceId) {
  204.     uni.getBLEDeviceServices({
  205.         deviceId,
  206.         success: (res) => {
  207.             console.log("获取蓝牙服务成功：" + JSON.stringify(res))
  208.             if (res.services.length == 0) {
  209.                 uni.hideLoading();
  210.                 app.alert('没有获取到蓝牙服务，无法打印001')
  211.                 app.global_printing = {}
  212.                 return false
  213.             }
  214.             for (let i = 0; i < res.services.length; i++) {
  215.                 if (res.services[i].isPrimary) {
  216.                     this.getBLEDeviceCharacteristics(deviceId, res.services[i].uuid)
  217.                     return
  218.                 }
  219.             }
  220.         },
  221.         fail: (res) => {
  222.             setTimeout(() => {
  223.                 this.getBLEDeviceServices(deviceId)
  224.             }, 500)
  225.             console.log("获取蓝牙服务失败：" + JSON.stringify(res))
  226.         }
  227.     })
  228. },
  229.  
  230.  
  231. //获取蓝牙设备某个服务中所有特征值(characteristic)
  232. getBLEDeviceCharacteristics(deviceId, serviceId) {
  233.     console.log('获取蓝牙设备某个服务中所有特征值', deviceId, serviceId)
  234.     uni.getBLEDeviceCharacteristics({
  235.         deviceId,
  236.         serviceId,
  237.         success: (res) => {
  238.             console.log('获取蓝牙设备某个服务中所有特征值 success', JSON.stringify(res))
  239.             uni.hideLoading();
  240.             if (res.characteristics.length == 0) {
  241.                 app.alert('没有获取到蓝牙服务，无法打印002')
  242.                 app.global_printing = {}
  243.                 return false
  244.             }
  245.             for (let i = 0; i < res.characteristics.length; i++) {
  246.                 let item = res.characteristics[i]
  247.                 if (item.properties.read) {
  248.                     uni.readBLECharacteristicValue({
  249.                         deviceId,
  250.                         serviceId,
  251.                         characteristicId: item.uuid,
  252.                     })
  253.                 }
  254.                 if (item.properties.write) {
  255.                     this.canWrite = true
  256.                     app.global_printing._deviceId = deviceId
  257.                     app.global_printing._serviceId = serviceId
  258.                     app.global_printing._characteristicId = item.uuid
  259.  
  260.                     app.saveData1('global_printing', app.global_printing)
  261.  
  262.                     //this.writeBLECharacteristicValue()
  263.                 }
  264.                 if (item.properties.notify || item.properties.indicate) {
  265.                     uni.notifyBLECharacteristicValueChange({
  266.                         deviceId,
  267.                         serviceId,
  268.                         characteristicId: item.uuid,
  269.                         state: true,
  270.                     })
  271.                 }
  272.             }
  273.         },
  274.         fail(res) {
  275.             console.error('获取特征值失败：', res)
  276.         }
  277.     })
  278.  
  279.     // 操作之前先监听，保证第一时间获取数据
  280.     uni.onBLECharacteristicValueChange((characteristic) => {
  281.         console.log(this.data.chs);
  282.         const idx = this.inArray(this.data.chs, 'uuid', characteristic.characteristicId)
  283.         const data = {}
  284.         if (idx === -1) {
  285.             this.chs[this.data.chs.length] = {
  286.                 uuid: characteristic.characteristicId,
  287.                 value: ab2hex(characteristic.value)
  288.             }
  289.         } else {
  290.             this.chs[idx] = {
  291.                 uuid: characteristic.characteristicId,
  292.                 value: ab2hex(characteristic.value)
  293.             }
  294.         }
  295.  
  296.     })
  297. },
  298.  
  299. onBLEConnectionStateChange() {
  300.     uni.onBLEConnectionStateChange((res) => {
  301.         // 该方法回调中可以用于处理连接意外断开等异常情况
  302.         console.log(`蓝牙连接状态改变device ${res.deviceId} state has changed, connected: ${res.connected}`)
  303.         if (res.connected == false) {
  304.             app.global_printing = {}
  305.             this.connected = false
  306.             this.chs = []
  307.             this.canWrite = false
  308.         }
  309.     })
  310. },
  311.  
  312.  
  313. //断开与低功耗蓝牙设备的连接
  314. closeBLEConnection() {
  315.     app.global_printing = {}
  316.     uni.closeBLEConnection({
  317.         deviceId: this.deviceId
  318.     })
  319.     this.connected = false
  320.     this.chs = []
  321.     this.canWrite = false
  322. },
  323.  
  324. //关闭蓝牙模块
  325. closeBluetoothAdapter() {
  326.     app.global_printing = {}
  327.     uni.closeBluetoothAdapter()
  328.     this.discoveryStarted = false
  329. },
  330.  
  331. //发送数据
  332. sendStr(bufferstr, success, fail) {
  333.     var that = this;
  334.     uni.writeBLECharacteristicValue({
  335.         deviceId: app.global_printing._deviceId,
  336.         serviceId: app.global_printing._serviceId,
  337.         characteristicId: app.global_printing._characteristicId,
  338.         value: bufferstr,
  339.         success: function(res) {
  340.             success(res);
  341.             console.log('发送的数据：' + bufferstr)
  342.             // console.log('message发送成功')
  343.         },
  344.         fail: function(res) {
  345.             fail(res)
  346.             console.log("数据发送失败:" + JSON.stringify(res))
  347.         },
  348.         complete: function(res) {
  349.             // console.log("发送完成:" + JSON.stringify(res))
  350.         }
  351.     })
  352. },
  353.  
  354.  
  355. //遍历发送数据
  356. printCode(arr) {
  357.     var that = this;
  358.     if (arr.length > 0) {
  359.         this.sendStr(arr[0], function(success) {
  360.             arr.shift();
  361.             that.printCode(arr);
  362.         }, function(error) {
  363.             app.alert('打印失败，错误码：' + error.errCode)
  364.             app.printing_status = false
  365.             console.log(error);
  366.         });
  367.         return false;
  368.     }
  369.  
  370.     setTimeout(function() {
  371.         app.printing_status = false
  372.         console.log('打印结束');
  373.     }, 1000);
  374. },

Android
就相对简单方便，采用Native.js直接调用Native Java接口通道，通过plus.android调用安卓原生系统API。
原生安卓文档 https://developer.android.google.cn/reference/android/bluetooth/BluetoothAdapter?hl=en

 复制代码
  1. // ======================Android============
  2. // 搜索蓝牙设备
  3. android_search(address = '') {
  4.     //搜索、配对
  5.     var main = plus.android.runtimeMainActivity();
  6.     var IntentFilter = plus.android.importClass('android.content.IntentFilter');
  7.     var BluetoothAdapter = plus.android.importClass("android.bluetooth.BluetoothAdapter");
  8.     var BluetoothDevice = plus.android.importClass("android.bluetooth.BluetoothDevice");
  9.     var BAdapter = BluetoothAdapter.getDefaultAdapter();
  10.     console.log("开始搜索设备");
  11.     var filter = new IntentFilter();
  12.     var bdevice = new BluetoothDevice();
  13.     var on = null;
  14.     var un = null;
  15.     console.log('正在搜索请稍候');
  16.     BAdapter.startDiscovery(); //开启搜索  
  17.     var receiver;
  18.     receiver = plus.android.implements('io.dcloud.android.content.BroadcastReceiver', {
  19.         onReceive: (context, intent) => { //实现onReceiver回调函数  
  20.             plus.android.importClass(intent); //通过intent实例引入intent类，方便以后的‘.’操作  
  21.             // console.log(intent.getAction()); //获取action  
  22.             if (intent.getAction() == "android.bluetooth.adapter.action.DISCOVERY_FINISHED") {
  23.                 main.unregisterReceiver(receiver); //取消监听  
  24.                 console.log("搜索结束")
  25.             } else {
  26.                 var BleDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  27.                 //判断是否配对  
  28.                 if (BleDevice.getBondState() == bdevice.BOND_NONE) {
  29.                     console.log("未配对蓝牙设备：" + BleDevice.getName() + '    ' + BleDevice.getAddress());
  30.                     //参数如果跟取得的mac地址一样就配对  
  31.                     if (address == BleDevice.getAddress()) {
  32.                         if (BleDevice.createBond()) { //配对命令.createBond()  
  33.                             if (BleDevice.getName() != null) {
  34.                                 console.log("配对成功蓝牙设备：" + BleDevice.getName() + '    ' +
  35.                                     BleDevice.getAddress());
  36.                                 // app.Toast("配对成功蓝牙设备：" + BleDevice.getName())
  37.                             }
  38.                         } else {
  39.                             console.log('配对失败')
  40.                         }
  41.                     } else {
  42.                         if (BleDevice.getName() != on) { //判断防止重复添加  
  43.                             on = BleDevice.getName();
  44.                             if (BleDevice.getName() != null) {
  45.                                 this.devices.push({
  46.                                     deviceId: BleDevice.getAddress(),
  47.                                     name: BleDevice.getName()
  48.                                 })
  49.                                 console.log("搜索到蓝牙设备：" + BleDevice.getName() + '    ' +
  50.                                     BleDevice.getAddress());
  51.                             }
  52.                         }
  53.                     }
  54.                 } else {
  55.                     if (BleDevice.getName() != un) { //判断防止重复添加  
  56.                         un = BleDevice.getName();
  57.                         if (BleDevice.getName() != null) {
  58.                             this.devices.push({
  59.                                 deviceId: BleDevice.getAddress(),
  60.                                 name: BleDevice.getName() + ' (已配对)',
  61.                                 pair: true
  62.                             })
  63.                             console.log("已配对蓝牙设备：" + BleDevice.getName() + '    ' + BleDevice.getAddress());
  64.                         }
  65.                     }
  66.                 }
  67.             }
  68.         }
  69.     });
  70.  
  71.     filter.addAction(bdevice.ACTION_FOUND);
  72.     filter.addAction(BAdapter.ACTION_DISCOVERY_STARTED);
  73.     filter.addAction(BAdapter.ACTION_DISCOVERY_FINISHED);
  74.     filter.addAction(BAdapter.ACTION_STATE_CHANGED);
  75.     main.registerReceiver(receiver, filter); //注册监听
  76. },
  77.  
  78. // 打印
  79. android_printCode(arr) {
  80.     
  81.     var that = this;
  82.  
  83.     // 打印
  84.     var device = null,
  85.         BAdapter = null,
  86.         BluetoothAdapter = null,
  87.         uuid = null,
  88.         main = null,
  89.         bluetoothSocket = null;
  90.  
  91.  
  92.     var mac_address = app.global_printing.deviceId
  93.  
  94.     var main = plus.android.runtimeMainActivity();
  95.     BluetoothAdapter = plus.android.importClass("android.bluetooth.BluetoothAdapter");
  96.     var UUID = plus.android.importClass("java.util.UUID");
  97.     uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
  98.     BAdapter = BluetoothAdapter.getDefaultAdapter();
  99.  
  100.     try {
  101.         device = BAdapter.getRemoteDevice(mac_address);
  102.         plus.android.importClass(device);
  103.         bluetoothSocket = device.createInsecureRfcommSocketToServiceRecord(uuid);
  104.         plus.android.importClass(bluetoothSocket);
  105.     } catch (e) {
  106.         console.log('asasssds-d=da=da-dsd');
  107.         app.printing_status = false
  108.         app.alert('打印失败')
  109.         return false;
  110.     }
  111.  
  112.  
  113.     if (!bluetoothSocket.isConnected()) {
  114.         console.log('检测到设备未连接，尝试连接....');
  115.         bluetoothSocket.connect();
  116.     }
  117.  
  118.     console.log('设备已连接');
  119.  
  120.     if (bluetoothSocket.isConnected()) {
  121.         var outputStream = bluetoothSocket.getOutputStream();
  122.         plus.android.importClass(outputStream);
  123.         
  124.         for (var i = 0; i < arr.length; i++) {
  125.             outputStream.write(arr[i]);
  126.         }
  127.  
  128.         outputStream.flush();
  129.         device = null //这里关键  
  130.         bluetoothSocket.close(); //必须关闭蓝牙连接否则意外断开的话打印错误  
  131.     }
  132.  
  133.     setTimeout(function() {
  134.         app.printing_status = false
  135.         console.log('打印结束');
  136.     }, 1000);
  137. },

打印指令（更多打印指令参考 https://www.jianshu.com/p/dd6ca0054298）

 复制代码
  1. /**
  2.  * 复位打印机
  3.  */
  4. public static final byte[] RESET = {0x1b, 0x40};
  5.  
  6. /**
  7.  * 左对齐
  8.  */
  9. public static final byte[] ALIGN_LEFT = {0x1b, 0x61, 0x00};
  10.  
  11. /**
  12.  * 中间对齐
  13.  */
  14. public static final byte[] ALIGN_CENTER = {0x1b, 0x61, 0x01};
  15.  
  16. /**
  17.  * 右对齐
  18.  */
  19. public static final byte[] ALIGN_RIGHT = {0x1b, 0x61, 0x02};
  20.  
  21. /**
  22.  * 选择加粗模式
  23.  */
  24. public static final byte[] BOLD = {0x1b, 0x45, 0x01};
  25.  
  26. /**
  27.  * 取消加粗模式
  28.  */
  29. public static final byte[] BOLD_CANCEL = {0x1b, 0x45, 0x00};
  30.  
  31. /**
  32.  * 宽高加倍
  33.  */
  34. public static final byte[] DOUBLE_HEIGHT_WIDTH = {0x1d, 0x21, 0x11};
  35.  
  36. /**
  37.  * 宽加倍
  38.  */
  39. public static final byte[] DOUBLE_WIDTH = {0x1d, 0x21, 0x10};
  40.  
  41. /**
  42.  * 高加倍
  43.  */
  44. public static final byte[] DOUBLE_HEIGHT = {0x1d, 0x21, 0x01};
  45.  
  46. /**
  47.  * 字体不放大
  48.  */
  49. public static final byte[] NORMAL = {0x1d, 0x21, 0x00};
  50.  
  51. /**
  52.  * 设置默认行间距
  53.  */
  54. public static final byte[] LINE_SPACING_DEFAULT = {0x1b, 0x32};

关于二维码的打印
通过上面的文章我们可以知道

我们需要读取生成后的二维码的像素点的rgba，再将图片数据先4合1判断0还是1(0代表打印1代表不打印)，紧接着八合1，因为一个字节有8位。最后使用打印机的位图指令逐行扫描打印

4合1
本想着二维码不是黑就是白，肯定不是255就是0，其实还是会有一小部分是其他数值的，这个要注意哦，每4位是一个像素点的rgba，然后黑白色的rgb就是(0,0,0)和(255,255,255)，所以每四位只把第一位黑白化，然后将每四位的第一位取出来作为新的数组，当rule>200的时候，值取0，表示不打印，否则取1，表示打印；

8合1
假如我们取出来的8位数是[0,0,0,0,0,0,0,1]，这个时候8合1，我们需要进行进制转换，从右往左是2的零次方，2的一次方，等等，依次上加，实际是 0 * 27 + 0 * 26 + 0 * 25 + 0 * 24 + 0 * 23 + 0 * 22 + 0 * 21 + 1 * 20,这个数就是我们要的最终数据的其中之一。

将数据转换成ArrayBuffer，其次打印必须要有指令！参考网址以及标准的ESC-POS指令集，下面代码中的数字都是指令，另外，由于我这边的打印机支持的是gb2312格式，所以在转成ArrayBuffer的同时，还需要把编码格式转成正确的格式。

不过有一点我是要说下的，要注意ios和安卓的不同，安卓一次只能写入不超过20字节（ios具体不清楚，目测120字节），建议是直接截取数据data.slice(20, byteLength)，打印成功再次回调，循环打印。

 复制代码
  1. // 二维码
  2. qr(text,callback) {
  3.     let that = this;
  4.     const ctx = uni.createCanvasContext('myQrcode');
  5.     ctx.clearRect(0, 0, 240, 240);
  6.     drawQrcode({
  7.         canvasId: 'myQrcode',
  8.         text: String(text),
  9.         width: 120,
  10.         height: 120,
  11.         callback(e) {
  12.             // setTimeout(() => {
  13.             // 获取图片数据
  14.             uni.canvasGetImageData({
  15.                 canvasId: 'myQrcode',
  16.                 x: 0,
  17.                 y: 0,
  18.                 width: 240,
  19.                 height: 240,
  20.                 success(res) {
  21.                     let arr = that.convert4to1(res.data);
  22.                     let data = that.convert8to1(arr);
  23.                     const cmds = [].concat([27, 97, 1], [29, 118, 48, 0, 30, 0,
  24.                             240, 0
  25.                         ],
  26.                         data, [27, 74, 3], [27, 64]);
  27.                     const buffer = toArrayBuffer(Buffer.from(cmds, 'gb2312'));
  28.                     
  29.                     // 二维码
  30.                     for (let i = 0; i < buffer.byteLength; i = i + 120) {
  31.                         that.arrPrint.push(buffer.slice(i, i + 120));
  32.                     }
  33.                     callback()
  34.                 }
  35.             })
  36.             // }, 3000);
  37.         }
  38.     });
  39. },

1、toArrayBuffer ,是个组件，要安装的，https://www.npmjs.com/package/to-array-buffer 或者你用这种写法也可以const buffer = new Uint8Array(Buffer.from(cmds, ‘gb2312’)).buffer;

2、注意查看自己的数据是否正确，画图的数据有问题的话，也可能打印出黑块；

3、数据要算！！！要算！！要算！！ ，比如我画图是160*160 ，然后我打印数据拼接的指令[29, 118, 48, 0, 20, 0, 160, 0]这个里面的20和160 这个就是算的，参考上方文章看下原因，大概就是1:8，然后画图和读图的数据一致

相关函数
（经过反复测试得出，打印纸一行最大字节数是32字节，这里指的是普通的票据打印机）
打印三列或者两列，是需要自己计算空格进行填充，没有现成的指令噢
总宽度 – 左侧文字长度 – 右侧文字长度 就是空格的长度。

 复制代码
  1. /**
  2.  * 打印两列
  3.  *
  4.  * @param leftText  左侧文字
  5.  * @param rightText 右侧文字
  6.  * @return
  7.  */
  8. printTwoData(leftText, rightText) {
  9.     var sb = ''
  10.     var leftTextLength = this.getBytesLength(leftText);
  11.     var rightTextLength = this.getBytesLength(rightText);
  12.     sb += leftText
  13.  
  14.     // 计算两侧文字中间的空格
  15.     var marginBetweenMiddleAndRight = 32 - leftTextLength - rightTextLength;
  16.  
  17.     for (var i = 0; i < marginBetweenMiddleAndRight; i++) {
  18.         sb += ' '
  19.     }
  20.     sb += rightText
  21.     return sb.toString();
  22. },
  23. /**
  24.  * 打印三列
  25.  *
  26.  * @param leftText   左侧文字
  27.  * @param middleText 中间文字
  28.  * @param rightText  右侧文字
  29.  * @return
  30.  */
  31. printThreeData(leftText, middleText, rightText) {
  32.     var sb = ''
  33.     // 左边最多显示 8 个汉字 + 两个点
  34.     if (leftText.length > 8) {
  35.         leftText = leftText.substring(0, 8) + "..";
  36.     }
  37.     var leftTextLength = this.getBytesLength(leftText);
  38.     var middleTextLength = this.getBytesLength(middleText);
  39.     var rightTextLength = this.getBytesLength(rightText);
  40.  
  41.     sb += leftText
  42.     // 计算左侧文字和中间文字的空格长度
  43.     var marginBetweenLeftAndMiddle = 20 - leftTextLength - middleTextLength / 2;
  44.  
  45.     for (var i = 0; i < marginBetweenLeftAndMiddle; i++) {
  46.         sb += ' '
  47.     }
  48.     sb += middleText
  49.  
  50.     // 计算右侧文字和中间文字的空格长度
  51.     var marginBetweenMiddleAndRight = 12 - middleTextLength / 2 - rightTextLength;
  52.  
  53.     for (var i = 0; i < marginBetweenMiddleAndRight; i++) {
  54.         sb += ' '
  55.     }
  56.  
  57.     sb += rightText
  58.  
  59.     // 打印的时候发现，最右边的文字总是偏右一个字符，所以需要删除一个空格
  60.     // sb.delete(sb.length() - 1, sb.length()).append(rightText);
  61.     return sb.toString();
  62. },
  63.  
  64. max(n1, n2) {
  65.     return Math.max(n1, n2)
  66. },
  67. len(arr) {
  68.     arr = arr || []
  69.     return arr.length
  70. },
  71.  
  72. //4合1 
  73. convert4to1(res) {
  74.     let arr = [];
  75.     for (let i = 0; i < res.length; i++) {
  76.         if (i % 4 == 0) {
  77.             let rule = 0.29900 * res[i] + 0.58700 * res[i + 1] + 0.11400 * res[i + 2];
  78.             if (rule > 200) {
  79.                 res[i] = 0;
  80.             } else {
  81.                 res[i] = 1;
  82.             }
  83.             arr.push(res[i]);
  84.         }
  85.     }
  86.     return arr;
  87. },
  88.  
  89. //8合1
  90. convert8to1(arr) {
  91.     let data = [];
  92.     for (let k = 0; k < arr.length; k += 8) {
  93.         let temp = arr[k] * 128 + arr[k + 1] * 64 + arr[k + 2] * 32 + arr[k + 3] * 16 + arr[k + 4] * 8 +
  94.             arr[k + 5] * 4 +
  95.             arr[k + 6] * 2 + arr[k + 7] * 1
  96.         data.push(temp);
  97.     }
  98.     return data;
  99. },
  100.  
  101.  
  102. inArray(arr, key, val) {
  103.     for (let i = 0; i < arr.length; i++) {
  104.         if (arr[i][key] === val) {
  105.             return i;
  106.         }
  107.     }
  108.     return -1;
  109. },
  110.  
  111.  
  112. // ArrayBuffer转16进度字符串示例
  113. ab2hex(buffer) {
  114.     var hexArr = Array.prototype.map.call(
  115.         new Uint8Array(buffer),
  116.         function(bit) {
  117.             return ('00' + bit.toString(16)).slice(-2)
  118.         }
  119.     )
  120.     return hexArr.join('');
  121. },
  122.  
  123.  
  124. // 计算文字占用长度
  125. getBytesLength(str) {
  126.     var num = str.length; //先用num保存一下字符串的长度（可以理解为：先假设每个字符都只占用一个字节）
  127.     for (var i = 0; i < str.length; i++) { //遍历字符串
  128.         if (str.charCodeAt(i) > 255) { //判断某个字符是否占用两个字节，如果是，num再+1
  129.             num++;
  130.         }
  131.     }
  132.     return num; //返回最终的num，既是字符串总的字节长度
  133. }


代码大多是直接从项目中copy过来的，没有整理过，并不能直接运行，仅供参考
不是我那一卷打印失败的打印纸丢了，不然就让你们看看什么叫做 第一次做打印机开发的程序员

这次是真大干货，篇幅也很长，辛苦了我

折腾 笔记 项目

  • avatar
    游客
    深圳自考 回复

    厉害了 简直一模一样 以后可以开一家不饿了么公司了aru_1

  • avatar
    游客
    一朵时光红 回复

    腾云奇袭技能释放时，神明将跳到筋斗云上，并留下一个完美的分身

  • avatar
    游客
    李鱼儿啊 回复

    楼主,向打印机发送给buffer的地方的代码可以详细一点嘛?我目前卡在这一步 很迷惑 可以加我QQ 2930962607

    • avatar
      博主
      阿珏 回复

      @ 李鱼儿啊 @李鱼儿啊：你得说清楚你的问题

      • avatar
        游客
        李鱼儿啊 回复

        @ 阿珏 @阿珏：我是uniApp的自定义组件模式开发 我是使用的native.js连接的Android手机的蓝牙 页面使用的是web-view的子窗口加载的本地html文件 因为需要使用html2canvas.js插件来截取页面生成图片 在插件的回调方法中可以获取到canvas的dom对象 因此可以获取到imageData的像素点信息 然后我使用你写得4合1 以及 8合1 生成数据 然后在发送到打印机的write方法时 我写了try catch 来捕获发送时的异常 发现问题出现在生成的数据上面 有时候catch会报错讲试图获取一个null Array的长度 有时候会直接报错一个空{} json对象 比较重要的点是 你在buffer数据的转换上面使用到了 node.js 的Buffer对象 但是我这边并不能使用 希望楼主可以帮忙解答一下 方便的话加一下QQ 2930962607

        • avatar
          博主
          阿珏 回复

          @ 李鱼儿啊 @李鱼儿啊：很抱歉，关于这个Android打印图片数据的问题，我这边也没有完全解决掉，没办法给你更好的解决方案。Android打印这块可以参考一下GoogleAndroid官方的文档，发送数据处理这块应该是有问题的。

  • avatar
    游客
    『乐 易』 回复

    这，不是类似于喵喵机的吗，正好我买个了喵喵机P1aru_1

    • avatar
      博主
      阿珏 回复

      @ 『乐 易』 @『乐 易』：这，貌似不是很一样，而且那不是叫咕咕机吗aru_2

      • avatar
        游客
        『乐 易』 回复

        @ 阿珏 @阿珏：功能一样，只不过喵喵机小一点而已，而且是喵喵机不是咕咕鸡aru_38

        • avatar
          博主
          阿珏 回复

          @ 『乐 易』 @『乐 易』：好吧好吧，原来还有一个叫喵喵机的玩意aru_16

  • avatar
    游客
    mengkun 回复

    很强！有饿了么订单条内味儿了aru_53

    • avatar
      博主
      阿珏 回复

      @ mengkun @mengkun：我们是不饿了么aru_42

  • avatar
    游客
    repostone 回复

    非技术的路过。

    • avatar
      博主
      阿珏 回复

      @ repostone @repostone：牛逼就完事了aru_43

发表评论
OωO表情

相关阅读

阿珏酱の杂货铺开张啦~

我的二次元相册又回来了

一款开源简洁高颜值的酷狗第三…

我的Github热榜

MoeKoeMusic
一款开源简洁高颜值的酷狗第三方客户端 An open-source, concise, and aesthetically pleasing third-party client for KuGou that supports Windows / macOS / Linux :electron:
9 小时前 1901 129 Vue
qr
QQ、支付宝、微信收款码三合一
2 周前 423 182 PHP
Fantasy-field
轻量级微博图床程序
2 周前 324 115 PHP
moeins
萌音影视 - 在线影视应用
4 天前 241 68 PHP
Alibaba_pic
一款美到不行的极简阿里图床
1 月前 171 80 HTML

最新文章

标签云

折腾闲言碎语二次元博客项目教程站点大事件开箱HTML笔记api编程1024插件CSS抓包猝不及防图包手办算法微信破解代码音乐

最新评论

恰饭

欢迎阅读『热敏蓝牙打印机开发 (゜-゜)つロ 干杯~』