waterElectricityMinApp/pages/reshui/reshui.vue

<template>
	<view class="content">
		<view class="container">
			<view class="header">
				<view class="scan" @tap="scan()" hover-class="scan_hover">
					<text class="iconfont icon-saoma"></text>
					<text>扫码连接</text>
				</view>
				<view class="qinshihao">
					<text class="iconfont icon-zhuye"></text>
					<text class="dormtxt">{{dorm_number || '宿舍未知'}}</text>
				</view>
			</view>
			<view class="start_text">
				<view class="start_top">
					<view class="item_left">
						<text class="iconfont icon-shuibiao"></text>
						<text>开启设备</text>
					</view>
					<view>
						<switch :color="colorPrimary" :checked="isChecked" @change="switchChange" />
					</view>
				</view>
				<view class="start_mid">
					<view class="item_left">
						<text class="iconfont icon-qian"></text>
						<text class="start_mid_txt">￥{{amount}}</text>
					</view>
					<view class="start_payamount" @tap="chongzhi_yemian()" hover-class="scan_hover">
						<text>点击充值</text>
						<text class="iconfont icon-dayuhao"></text>
					</view>
				</view>
				<view class="start_bot">
					<text class="start_bot_txt" v-if="false">时长：00:00:00</text>
					<text class="start_bot_txt">当前结算消费：￥{{use_amount}}</text>
				</view>
			</view>
			<view class="start_up_process">
				<uni-steps :options="list1" :active-color="colorPrimary" :active="active" />
			</view>
			<view class="title">
				消费记录
			</view>
			<view class="record-item">
				<view class="uni-list-cell-db">
					<picker mode="date" :value="date" fields="month" :start="startDate" :end="endDate"
						@change="bindDateChange">
						<view class="uni-input">
							<text>{{date}}</text>
							<text class="iconfont icon-arrow-down"></text>
						</view>
					</picker>
				</view>
				<view class="item-list" v-for="(item, i) in xiaofei_items" :key="i">
					<text class="item-list-txt"><text class="iconfont icon-shijian"></text>{{item.begin_time}}</text>
					<text class="item-list-txt"><text class="iconfont icon-shuidi"></text>{{item.use_size}}升</text>
					<text class="item-list-txt">{{item.use_amount}}</text>
				</view>
			</view>
		</view>
		<instructions v-if="flag" @parent_cancel="cancel" @parent_noshow='noshow'></instructions>
	</view>
</template>

<script>
	import instructions from '../../components/instructions.vue'

	export default {
		/**
		 * 声明组件
		 */
		components: {
			instructions
		},
		data() {
			return {
				colorPrimary: getApp().globalData.primaryColor,
				date: this.$getDate({
					format: true
				}),
				startDate: this.$getDate('start_date'),
				endDate: this.$getDate('end_date'),
				flag: false,
				isUserClose: false, // 是否是用户自己关闭
				isChecked: false,
				isConnected: false, // 是否连接上
				isScan: false,
				active: -1,
				list1: [{
					title: '连接设备'
				}, {
					title: '连设备服务'
				}, {
					title: '数据通讯'
				}, {
					title: '启动'
				}],
				devices: [], // 保存设备
				device_code: '', // 设备编号
				deviceId: '',
				serviceId: '',
				characteristicIdForWrite: '',
				characteristicIdForNotity: '',
				deviceIsNotify: false,
				deviceIsWrite: false,
				byte35: '', // 70 个字符
				byte35_tmp: '', // 70 个字符 临时变量
				start_code: '',
				// start_code: '3459A8C660F1C284E41003E80000120000',
				xiaofei_items: [], // 消费记录
				use_amount: 0.0.toFixed(2), // 结算金额
				amount: 0.0.toFixed(2), // 余额
				dorm_number: '', // 宿舍号
				stu_number: '', // 学号
				// compus: '', // 校区
				ceshi: 'code',
				changeDate: false // 是否是手动选择日期
			}
		},
		onLoad(options) {
			// console.log(options);
			if (typeof(options) != 'undefined' && typeof(options) != '' && JSON.stringify(options) == '{}') {
				// 获取基本信息
				this.get_base_info(options, 'onLoad')
			} else if (typeof(options.from) != 'undefined' && options.from != 0) {
				uni.navigateTo({
					url: '../index/index?from=' + options.from
				})
			} else {
				// wxminicode=KB580002652
				this.start_code = decodeURIComponent(options.q).split('=')[1]
				// 初始化蓝牙
				this.openBluetoothAdapter()
			}
		},
		onShow() {
			// 获取基本信息
			this.get_base_info('options', 'onShow')
		},
		methods: {
			/**
			 * 获取基本信息
			 */
			get_base_info(options, param) {
				// console.log(options);
				try {
					// 获取学号
					this.stu_number = this.$store.state.userInfo.card_number

					if (this.stu_number == '' || typeof(this.stu_number) == 'undefined') {
						const userinfo = uni.getStorageSync('userinfo_storage_key')
						if (userinfo) {
							this.stu_number = userinfo.card_number
						} else {
							uni.navigateTo({
								url: '../index/index?from=' + options.from
							})

							uni.showToast({
								icon: 'none',
								title: '学号为空，请进行授权',
								duration: 3000
							});
						}
					} else {
						const value = uni.getStorageSync('instruction_noshow');
						if (!value) {
							this.flag = true
						}
						// 获取code
						this.getCode(options, param)
					}
				} catch (e) {
					console.log(e);
				}

				if (param == 'onShow') {
					if (this.$store.state.payInfo.from == 'reshui_pay') {
						uni.showToast({
							title: this.$store.state.payInfo.resultMsg,
							icon: 'success',
							success: () => {
								this.$store.state.payInfo.resultMsg = ''
								this.$store.state.payInfo.from = ''
							}
						})

						// this.amount = this.$store.state.reshui_amount + this.amount
						// 重新调用一次，刷新金额
						this.getCode(options, param)
					}
				}
			},
			/**
			 * 获得code
			 */
			getCode(options, param) {
				uni.login({
					success: (res) => {
						// console.log('reshui', res);
						if (res.code) {
							// 请求服务器，获得openid
							this.getOpenId(options, res.code, param)
						} else {
							uni.showToast({
								title: res.errMsg,
								icon: 'none'
							});
						}
					}
				})
			},
			/**
			 * 请求服务器，获得openid
			 */
			async getOpenId(options, param_code, param) {
				const res = await this.$myRequest({
					host: this.ceshi,
					url: '/HotWaters/wpget_stu.action',
					method: 'POST',
					header: {
						'content-type': 'application/x-www-form-urlencoded'
					},
					data: {
						code: param_code
					}
				})

				// console.log(res);
				if (res.data.mess == '返回成功') {
					// 判断存储的stu_number与返回的stu_number是否一致
					let cardNumber = res.data.info[0].card_number
					if (typeof(cardNumber) != 'undefined' && cardNumber != '' && JSON.stringify(cardNumber) != '{}') {
						// 学号
						this.stu_number = res.data.info[0].stu_number
						// 剩余金额
						this.amount = res.data.info[0].balance.toFixed(2)
						if (this.amount > 0)
							this.$store.state.reshui_amount = this.amount
						// 组合楼栋宿舍号
						this.dorm_number = res.data.info[0].build + res.data.info[0].dom
						// 校区
						// this.compus = res.data.info[0].campus

						if (param == 'onLoad') {
							// 请求选定的月份消费记录
							this.request_consumption_records()
						}
					} else {
						uni.showToast({
							title: '未获取到学号!',
							icon: 'success'
						});

						uni.navigateTo({
							url: '../index/index?from=' + options.from
						})
					}
				} else if (res.data.mess == '未查询到用户信息') {
					if (options && typeof(options.from) != 'undefined' && typeof(options.from) != '') {
						uni.navigateTo({
							url: '../index/index?from=' + options.from
						})
					} else {
						uni.redirectTo({
							url: '../index/index?from=0'
						});
					}
				}
			},
			/**
			 * 选择消费年月
			 */
			bindDateChange(e) {
				this.date = e.detail.value
				this.changeDate = true
				// 请求选定的月份消费记录
				this.request_consumption_records()
			},

			/**
			 * 使用说明组件取消
			 */
			cancel(param) {
				this.flag = param
			},
			/**
			 * 使用说明组件不再出现
			 */
			noshow(param) {
				try {
					if (param) {
						uni.setStorageSync("instruction_noshow", true)
					} else {
						uni.removeStorageSync("instruction_noshow")
					}
				} catch (e) {
					console.log(e);
				}
			},
			/**
			 * 请求选定的月份消费记录
			 */
			async request_consumption_records() {
				if (this.stu_number != '' && typeof(this.stu_number) != 'undefined') {
					const res = await this.$myRequest({
						host: this.ceshi,
						url: '/HotWaters/wpqueryConsume.action',
						method: 'POST',
						header: {
							'content-type': 'application/x-www-form-urlencoded'
						},
						data: {
							stu_number: this.stu_number,
							begin_time: this.date
						}
					});

					// console.log(res);
					if (res.data.mess == '返回成功') {
						this.xiaofei_items = []
						// 消费记录
						let items = res.data.data
						for (var i = 0; i < items.length; i++) {
							this.xiaofei_items.push(items[i])
						}
					} else {
						if (this.changeDate) {
							uni.showToast({
								icon: 'success',
								title: res.data.mess,
								success: () => {
									this.changeDate = false
								}
							})
						}
					}
				} else {
					uni.showToast({
						icon: 'success',
						title: '未获得学号'
					})
				}
			},
			/**
			 * 控制进度条显示
			 * @param {Object} active_value
			 */
			process_control(active_value) {
				if (active_value <= this.list1.length - 1) {
					this.active = active_value
				}
			},

			/**
			 * 开始或停止用水
			 */
			switchChange(e) {
				this.isChecked = e.target.value
				if (this.isChecked) {
					if (this.deviceId && this.serviceId && this.devices.length != 0) {
						uni.showModal({
							title: '提示',
							content: '确定要启动设备？',
							success: (res) => {
								if (res.confirm) {
									this.isChecked = true

									// 开始连接匹配的蓝牙设备
									setTimeout(async () => {
										// 请求获取设备启动码
										this.request_device_start_code()
									}, 300)
								} else if (res.cancel) {
									setTimeout(() => {
										this.isChecked = false
									}, 300)
								}
							}
						})
					} else {
						uni.showToast({
							icon: 'none',
							title: '先【扫码连接】，后【开启设备】',
							duration: 1500
						})

						setTimeout(() => {
							this.isChecked = false
						}, 300)
					}
				} else {
					uni.showModal({
						title: '提示',
						content: '确定要关闭设备？',
						success: (res) => {
							if (res.confirm) {
								this.isChecked = false

								if (this.deviceId && this.serviceId) {
									this.send('stop')
								} else {
									uni.showToast({
										icon: 'none',
										title: '与设备连接中断！请在设备上手动停止即可！',
										duration: 5000
									})

									setTimeout(() => {
										this.isChecked = true
									}, 300)
								}
							} else if (res.cancel) {
								setTimeout(() => {
									this.isChecked = true
								}, 300)
							}
						}
					})
				}
			},

			/**
			 * 跳转到充值页面并传参数
			 */
			chongzhi_yemian() {
				//在起始页面跳转到recharge.vue页面并传递参数
				uni.navigateTo({
					url: '../recharge/recharge'
				});
			},

			/**
			 * 111111111111111111111111111111
			 * 扫码连接设备
			 */
			scan() {
				// 启动最低金额限制
				if (this.amount < 10) {
					uni.showModal({
						title: '提示',
						content: '当前余额不足￥10元',
						cancelText: '我知道了',
						confirmText: '我要充值',
						success: (res) => {
							if (res.confirm) {
								// 跳转充值页面并传参数
								this.chongzhi_yemian()
							} else if (res.cancel) {
								return
							}
						}
					})
				} else {
					// 已经启动扫描连接设备中
					if (this.isScan) {
						uni.showToast({
							icon: 'none',
							title: '正在扫描，请耐心等待',
						})
						return
					}
					// 已经启动设备,不启动扫描
					if (this.isChecked) {
						uni.showToast({
							icon: 'none',
							title: '设备已启动，无需重新扫码',
						})
						return
					}

					if (this.deviceId) {
						uni.showModal({
							title: '提示',
							content: '设备已经连接，需要重新连接吗？',
							success: res => {
								if (res.confirm) {
									this.closeBLEConnection()

									this.scan_qr()
								} else if (res.cancel) {
									return
								}
							}
						})
					} else {
						this.scan_qr()
					}
				}
			},
			/**
			 * 启动摄像头,扫描二维码
			 */
			scan_qr() {
				uni.scanCode({
					onlyFromCamera: true,
					success: (res) => {

						this.isScan = true
						// console.log(res)
						// charSet: "utf-8"
						// codeVersion: 3
						// errMsg: "scanCode:ok"
						// rawData: "aHR0cDovL3Rvb2xzLjlrYnMuY29tLz93eG1pbmljb2RlPUtCNTgwMDAyNjUy"
						// result: "http://tools.9kbs.com/?wxminicode=KB580002652"
						// scanType: "QR_CODE"
						this.device_code = res.result.split('?')[1].split('=')[1]

						if (this.device_code === '') {
							uni.showToast({
								icon: 'success',
								title: '获取设备码失败',
								duration: 3000
							})

							this.isScan = false
						} else {
							// 初始化蓝牙
							this.openBluetoothAdapter()
						}
					}
				})
			},

			/**
			 * 22222222222222222222222222222
			 * 初始化蓝牙
			 */
			openBluetoothAdapter() {
				uni.openBluetoothAdapter({
					success: (res) => { // 已打开
						uni.getBluetoothAdapterState({ // 蓝牙的匹配状态
							success: (res1) => {
								// console.log(res1, '“本机设备的蓝牙已打开”');
								// 本机设备的蓝牙已打开
								// 开始搜索蓝牙设备
								if (this.deviceId == '' && this.serviceId == '')
									this.startBluetoothDeviceDiscovery()
							},
							fail: (error) => {
								// console.log(error)
								uni.showToast({
									title: "请开启手机蓝牙",
									icon: "none",
									duration: 3000
								})

								this.isScan = false
							}
						});
					},
					fail: (err) => { // 未打开
						// console.log(err)
						this.isScan = false
						if (err.errCode == 10001) {
							uni.showModal({
								content: '请开启手机蓝牙！',
								showCancel: false,
							})
						} else {
							uni.showToast({
								title: err.errMsg,
								duration: 2000
							})
						}
					}
				});
			},

			/**
			 * 333333333333333333333333333
			 * 开始搜索蓝牙设备
			 */
			startBluetoothDeviceDiscovery() {
				uni.startBluetoothDevicesDiscovery({ // 开始搜寻附近的蓝牙外围设备
					// services: ['FEE7'],   // 要搜索但蓝牙设备主 service 的 uuid 列表
					allowDuplicatesKey: true,
					success: (res) => {

						this.process_control(0);

						this.onBluetoothDeviceFound() //监听搜索到新设备  同时进行
					},
					fail: err => {
						// console.log(err, '错误信息');
						uni.showToast({
							title: err.errMsg,
							duration: 2000
						})

						this.isScan = false
					}
				})
			},

			stopBluetoothDevicesDiscovery: function() { //停止搜索
				uni.stopBluetoothDevicesDiscovery({
					success: (res) => {
						// console.log(res, '停止蓝牙搜索')
						// uni.showToast({
						// 	title: '停止蓝牙搜索',
						// 	duration: 2000
						// })

						this.process_control(0);

						// 开始连接匹配的蓝牙设备
						this.createBLEConnection()
					},
					fail: e => {
						// console.log('停止搜索蓝牙设备失败，错误码：' + e.errCode);
						this.isScan = false
						uni.showToast({
							title: err.errCode,
							duration: 2000
						})
					}
				})
			},

			/**
			 * 444444444444444444444444444444444
			 * 发现外围设备
			 */
			onBluetoothDeviceFound() {
				uni.onBluetoothDeviceFound((res) => {
					res.devices.forEach(device => { // 筛选找到的蓝牙中对名称匹配
						// 过滤掉没有名字的设备
						if (!device.name && !device.localName) {
							return
						}

						if (device.name == this.device_code) {
							//data里面建立一个deviceId、device_code，存储起来
							// this.device_code = device.name;
							this.deviceId = device.deviceId
							// 把搜索到的设备存储起来，如有需要可以在页面上展示
							if (this.devices.indexOf(res.devices[0].deviceId) == -1) {
								this.devices.push(res.devices[0].deviceId)
							}

							this.process_control(0);

							this.stopBluetoothDevicesDiscovery()
						}
					})
				});
			},

			/**
			 * 555555555555555555555555555555555
			 * 连接蓝牙设备
			 */
			createBLEConnection() {
				//连接蓝牙
				uni.createBLEConnection({
					deviceId: this.deviceId,
					timeout: 3000,
					success: (res) => {
						// console.log(res)
						this.connect_BLE()
					},
					fail: (err) => {
						// console.log(err)
						this.isScan = false
						if (err.errMsg.indexOf('already connect') != -1) {
							this.connect_BLE()
						} else {
							uni.showToast({
								title: '建立连接失败',
								icon: 'none',
								duration: 3000,
								success: (res1) => {
									this.setInit()
								}
							})
						}
					}
				})
			},

			connect_BLE() {
				if (this.isConnected === false) {
					this.isConnected = true

					this.process_control(1);

					// 获取蓝牙设备所有服务(service)
					this.getBLEDeviceServices()
				}
			},

			/**
			 * 6666666666666666666666666666666666
			 * 获取蓝牙的所有服务
			 */
			getBLEDeviceServices() {
				uni.getBLEDeviceServices({
					deviceId: this.deviceId,
					success: (res) => {
						// console.log(res)
						// res1.services.forEach((item) => {
						// 	this.getBLEDeviceCharacteristics()
						// })
						this.serviceId = res.services[1].uuid

						this.process_control(1);

						this.getBLEDeviceCharacteristics(this.deviceId, res.services[1].uuid)
					},
					fail: (err) => {
						// console.log(err)
						this.isScan = false
						uni.showToast({
							title: '获取服务失败',
							icon: 'none',
							duration: 3000
						})
						return
					}
				});
			},

			/**
			 * 777777777777777777777777777777777
			 * 获取蓝牙特征
			 */
			getBLEDeviceCharacteristics() {
				// 获取蓝牙设备某个服务中所有特征值(characteristic)
				uni.getBLEDeviceCharacteristics({
					deviceId: this.deviceId,
					// 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
					serviceId: this.serviceId,
					success: (res) => {

						this.process_control(2);

						// console.log(res)
						this.characteristicIdForWrite = res.characteristics[0].uuid
						this.characteristicIdForNotity = res.characteristics[1].uuid
						this.deviceIsWrite = res.characteristics[0].properties.write
						this.deviceIsNotify = res.characteristics[1].properties.notify
						// console.log(this.characteristicIdForWrite, this.characteristicIdForNotity)
						// 确保对应服务id下的特征值id具备监听数据变化的特性
						if (res.characteristics[1].properties.notify) {
							this.notifyBLECharacteristicValueChange()
						}
					},
					fail: (err) => {
						this.isScan = false
						// console.error('获取蓝牙设备特征值失败(getBLEDeviceCharacteristics)', err)
					}
				});
			},

			/**
			 * 888888888888888888888888888888888888
			 * 启用 notify 功能
			 */
			notifyBLECharacteristicValueChange() {
				// console.log(characteristicId, 'characteristicId')
				uni.notifyBLECharacteristicValueChange({
					state: true, // 启用 notify 功能
					deviceId: this.deviceId,
					// 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
					serviceId: this.serviceId,
					// 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
					characteristicId: this.characteristicIdForNotity,
					success: (res) => {
						this.process_control(2)
						this.isScan = false
						// console.log('通知启用(notifyBLECharacteristicValueChange)',res);
						this.onBLECharacteristicValueChange()

						setTimeout(() => {
							// 发送 AAABAC，采集数据（会返回 35字节 的数据）
							this.send('')
						}, 300)

						// // 请求设备信息
						// this.request_device_info()

						// // 显示设备启动授权金额
						// this.display_device_startup_amount()
					},
					fail: (err) => {
						// console.log(err)
						this.isScan = false
						uni.showModal({
							content: err.errMsg,
							showCancel: false
						})
					}
				})
			},

			/**
			 * 999999999999999999999999999999999
			 * 监听低功耗蓝牙设备的特征值变化
			 */
			onBLECharacteristicValueChange() {
				uni.onBLECharacteristicValueChange((characteristic) => {
					let condition = ab2hex(characteristic.value)

					// console.log(condition)
					if (condition.length > 2) {
						this.byte35_tmp += condition
						if (this.byte35_tmp.length > 40) {
							this.byte35 = this.byte35_tmp
							this.byte35_tmp = ''

							if (this.byte35.startsWith('ad')) {
								// console.log(this.byte35, '结束用水成功')
								// 关闭蓝牙连接
								this.closeBLEConnection()

								// 请求结算
								this.request_pay()

							} else {
								// 发送 AAABAC，采集数据（会返回 35字节 的数据）
								// b58000265243eb3dd4bb3c5a2ab9042efcf0d2a30a000000000000000014392a0103bc
								// uni.showToast({
								// 	icon: 'success',
								// 	title: '采集数据成功！',
								// 	duration: 2000
								// })

								// console.log(this.byte35, '采集上一条消费数据')
							}
						}
					}

					switch (condition) {
						case 'bb':
							// uni.showToast({
							// 	title: '设备启动成功',
							// 	duration: 3000,
							// 	icon: 'none'
							// })

							this.process_control(3)
							this.isChecked = true

							break
						case 'bc':
							uni.showToast({
								title: '启动失败，设备检验启动代码不通过',
								duration: 3000,
								icon: 'none'
							})
							break
						case 'aa':
							uni.showToast({
								title: '设备正在使用',
								duration: 3000,
								icon: 'none'
							})
							break
						case 'ab':
							uni.showToast({
								title: '结束失败，设备对结束代码检验失败',
								duration: 3000,
								icon: 'none'
							})
							break
						default:
							break
					}
				})
			},

			/**
			 * 关闭连接
			 */
			closeBLEConnection() {
				uni.closeBLEConnection({
					deviceId: this.deviceId,
					success: () => {
						// 关闭蓝牙模块
						this.closeBluetoothAdapter()
					},
					fail: () => {
						uni.showToast({
							icon: 'none',
							title: '蓝牙连接断开失败',
							duration: 3000,
							success: (res1) => {
								this.setInit()
							}
						})
					}
				})
			},

			closeBluetoothAdapter() {
				// 关闭蓝牙模块
				uni.closeBluetoothAdapter({
					success: () => {
						this.setInit()

						if (this.isUserClose == false) { // 设备端结束用水
							if (this.isChecked) {
								// console.log('设备端已结束用水，蓝牙断开成功')
								uni.showToast({
									icon: 'none',
									title: '设备端已结束用水，蓝牙断开成功',
									duration: 3000
								})
							} else {
								// console.log('用户重启扫描，蓝牙断开成功')
								uni.showToast({
									icon: 'none',
									title: '用户重启扫描，蓝牙断开成功',
									duration: 3000
								})
							}
						} else { // 手机移动端结束用水
							// console.log('APP端已结束用水，蓝牙断开成功')
							uni.showToast({
								icon: 'none',
								title: 'APP端已结束用水，蓝牙断开成功',
								duration: 3000
							})
						}
					}
				})
			},

			setInit() {
				setTimeout(() => {
					this.isUserClose = false
					this.isChecked = false
					this.isConnected = false
					this.isScan = false
					this.active = -1
					this.devices = [] // 保存设备
					this.device_code = '' // 设备编号
					this.deviceId = ''
					this.serviceId = ''
					this.characteristicIdForWrite = ''
					this.characteristicIdForNotity = ''
					this.deviceIsNotify = false
					this.deviceIsWrite = false
					this.byte35 = '' // 70 个字符
					this.byte35_tmp = '' // 70 个字符 临时变量
					// this.start_code = ''
				})
			},

			/**
			 * 10===========10==================10
			 * 发送数据到设备
			 */
			send(val) {
				let buffer
				let dataView
				let newArr
				if (val == 'start') { // 启动设备
					this.isUserClose = false

					this.process_control(3)
					// this.createBLEConnection()
					// 发送 17字节 启动代码（会返回 35字节 的数据）
					// b58000265243eb3dd4bb3c5a2ab9042efcf0d2a30a000000000000000014392a0103bc
					newArr = str2StrArray(this.start_code)
				} else if (val == 'stop') { // 结束当前使用，设备成功返回：AD+35字节 消费结算代码
					this.isUserClose = true
					// 发送 AAABAD+17字节 启动代码（会返回 ad+35字节 的数据）
					// adb58000265243eb3dd4bb3c5a2ab9042efcf0d2a30a000000000000000014392a0104bc
					newArr = ['AA', 'AB', 'AD'].concat(str2StrArray(this.start_code))
				} else {
					// 发送 AAABAC 采集数据（会返回 35字节 的数据）
					// b58000265243eb3dd4bb3c5a2ab9042efcf0d2a30a000000000000000014392a0103bc
					newArr = ['AA', 'AB', 'AC']
				}

				buffer = new ArrayBuffer(newArr.length)
				dataView = new DataView(buffer)
				newArr.forEach((item, i) => {
					dataView.setUint8(i, sixteen_to_ten(item))
				})

				// 写特征值数据到设备
				if (this.deviceIsWrite) {
					// 写数据到设备
					this.writeBLECharacteristicValue(val, buffer)
				} else {
					uni.showToast({
						title: '设备不可写',
						duration: 3000
					})
				}
			},

			/**
			 * 11====================11=====================11
			 * 写数据到设备
			 */
			writeBLECharacteristicValue(val, buffer) {
				uni.writeBLECharacteristicValue({
					deviceId: this.deviceId,
					// 这里的 serviceId 需要在 getBLEDeviceServices 接口中获取
					serviceId: this.serviceId,
					// 这里的 characteristicId 需要在 getBLEDeviceCharacteristics 接口中获取
					characteristicId: this.characteristicIdForWrite,
					// 这里的value是ArrayBuffer类型
					value: buffer,
					success: (res) => {
						// console.log(res)
						if (val == 'start') {
							setTimeout(() => {
								this.isChecked = true
								this.isConnected = true
							}, 300)

							this.process_control(3)
						} else if (val == 'stop') {
							setTimeout(() => {
								this.isChecked = false
							}, 300)
						}
					},
					fail: (err) => {
						// console.log(err)
						if (err.errCode == 10006) {
							setTimeout(() => {
								this.setInit()
							}, 300)

							if (this.isConnected) {
								uni.showToast({
									title: '设备连接已断开！请在水表上手动停止！',
									icon: 'none'
								})
							} else {
								uni.showToast({
									title: '设备连接失败！请重试扫描连接！',
									icon: 'none'
								})
							}
						}
					}
				})
			},

			/**
			 * 请求获取设备启动码
			 */
			async request_device_start_code() {
				if (this.byte35 != '' && this.stu_number != '') {
					const res = await this.$myRequest({
						host: this.ceshi,
						url: '/HotWaters/wpstart.action',
						data: {
							collect_code: this.byte35,
							stu_number: this.stu_number
						}
					})

					// console.log(res)
					if (res.data.start_code != 'undefined' && res.data.start_code != '') {
						this.start_code = res.data.start_code
						this.send('start')
					} else {
						uni.showToast({
							title: res.data.mess,
							duration: 3000
						})
					}
				} else {
					uni.showToast({
						title: '字节码或学号为空！'
					});
					// 初始化
					this.setInit()
				}
			},

			/**
			 * 请求结算
			 */
			async request_pay() {
				if (this.byte35 != '') {
					const res = await this.$myRequest({
						host: this.ceshi,
						url: '/HotWaters/wpconsume.action',
						data: {
							collect_code: this.byte35.substring(2)
						}
					})

					// console.log(res)
					if (res.data.mess == "支付成功") {
						uni.showToast({
							icon: 'success',
							title: '结算成功！',
							success: (res1) => {
								this.use_amount = res.data.use_amount.toFixed(2)
								this.amount = (this.amount - this.use_amount).toFixed(2)
								// 刷新选定的月份消费记录
								this.request_consumption_records()
							}
						})
					} else {
						uni.showToast({
							icon: 'success',
							title: '结算失败！',
							duration: 3000
						})
					}
				} else {
					uni.showToast({
						title: '字节码为空！',
						icon: 'success'
					});
					// 初始化
					this.setInit()
				}
			}
		}
	}

	/**
	 * 返回字符处理
	 */
	function str2StrArray(start_code) {
		if (start_code.length != 34) {
			// console.log('启动码长度错误')
			throw new Error("启动码长度错误");
			return
		}
		var resultArray = new Array()
		for (var i = 0; i < start_code.length; i += 2) {
			resultArray.push(start_code.substr(i, 2));
		}

		return resultArray;
	}

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

	/**
	 * 16进制转10进制
	 */
	function sixteen_to_ten(str) {
		return parseInt(str, 16);
	}
</script>

<style scoped lang="scss">
	.content {
		width: 100%;
		height: 100%;

		.container {
			width: 100%;
			padding: 20rpx 40rpx;
			box-sizing: border-box;

			.header {
				display: flex;
				justify-content: center;
				position: relative;
				height: 200rpx;

				.scan {
					display: flex;
					flex-direction: column;
					justify-content: center;
					align-items: center;
					height: 200rpx;
					width: 30%;

					.iconfont {
						margin-bottom: 10rpx;
						font-size: 100rpx;
						color: $my-color-primary;
					}
				}

				.scan_hover {
					border-radius: 15rpx;
					background-color: $my-color-btn-background;
				}

				.qinshihao {
					display: flex;
					align-items: center;
					position: fixed;
					top: 20rpx;
					right: 30rpx;
					font-size: 28rpx;

					.icon-zhuye {
						margin-right: 10rpx;
						font-family: Microsoft YaHei-3970(82674968);
						color: $my-color-primary;
					}

					.compustxt {
						font-size: 18rpx;
					}
				}
			}

			.start_text {

				.start_top,
				.start_mid {
					display: flex;
					justify-content: space-between;
					height: 100rpx;
					align-items: center;
					border-bottom: 2rpx #ccc solid;

					.item_left {
						display: flex;
						align-items: center;
					}

					.start_mid_txt {
						color: #333;
						font-size: 30rpx;
					}

					.iconfont {
						font-size: 50rpx;
						color: $my-color-primary;
						margin-right: 20rpx;
					}

					.start_payamount {
						display: flex;
						justify-content: flex-end;
						align-items: center;
						font-size: 38rpx;
						padding: 10rpx;
						font-family: Microsoft YaHei-3970(82674968);
						color: #B2B2B2;
						border-radius: 10rpx;

						.icon-dayuhao {
							margin: 0 0 0 20rpx;
							font-size: 38rpx;
							color: #B2B2B2;
						}
					}
				}

				.start_bot {
					display: flex;
					justify-content: flex-end;
					height: 100rpx;
					align-items: center;

					.start_bot_txt {
						margin-left: 20rpx;
						color: #333;
						font-size: 28rpx;
					}
				}
			}

			.start_up_process {
				padding: 20rpx 0;
				color: #007AFF;
			}

			.title {
				height: 100rpx;
				margin: 0 -40rpx;
				padding: 0 40rpx;
				line-height: 100rpx;
				color: #808080;
				font-size: 32rpx;
				background: #f2f2f2;
			}

			.record-item {
				width: 100%;

				.uni-list-cell-db {
					height: 100rpx;
					line-height: 100rpx;
					font-weight: bold;

					.uni-input {
						display: flex;
						align-items: center;

						text:nth-child(1) {
							margin-right: 10rpx;
						}
					}
				}

				.item-list {
					height: 80rpx;
					display: flex;
					align-items: center;
					justify-content: space-between;
					border-top: 2rpx #ccc solid;

					.icon-shijian {
						margin-right: 8rpx;
					}

					.icon-shuidi {
						margin-right: 3rpx;
					}

					.item-list-txt {
						font-size: 28rpx;

						&:nth-of-type(2) {
							color: #515151;
						}

						&:nth-of-type(3) {
							color: #f76200;
							font-size: 32rpx;
						}
					}
				}
			}
		}
	}
</style>