Merge branch 'main' of http://47.107.152.87:3000/dyf/APP

components/TextToHex/textToDotMatrixFor7305.vue

@@ -1,6 +1,6 @@
 <template>
 	<view>
-		<canvas type="2d" canvas-id="reusableCanvas" :width="currentCanvasWidth" :height="currentCanvasHeight"
+		<canvas canvas-id="reusableCanvas" :width="currentCanvasWidth" :height="currentCanvasHeight"
 			class="offscreen-canvas"></canvas>
 	</view>
 </template>
@@ -27,6 +27,16 @@
 			color: {
 				type: String,
 				default: "#000000"
+			},
+			// 二值化阈值（0~1），越大越细；默认偏清晰
+			threshold: {
+				type: Number,
+				default: 0.45
+			},
+			// 是否启用轻度笔画修复（3x3 膨胀）；默认关闭以避免变粗
+			sharpen: {
+				type: Boolean,
+				default: false
 			}
 		},
 		data() {
@@ -48,6 +58,16 @@
 			this.ctx = uni.createCanvasContext('reusableCanvas', this);
 		},
 		methods: {
+			/**
+			 * 外部可调用：复位画布为纯背景并立即提交
+			 */
+			async resetCanvas() {
+				if (!this.ctx) return;
+				this.clearCanvas();
+				await new Promise((resolve) => {
+					this.ctx.draw(true, () => setTimeout(resolve, 30));
+				});
+			},
 			/**
 			 * 估算单行文本所需的Canvas宽度
 			 */
@@ -59,6 +79,8 @@
 			 * 清除Canvas内容
 			 */
 			clearCanvas() {
+				// 先清除，再用背景色填充，确保无残留
+				this.ctx.clearRect(0, 0, this.currentCanvasWidth, this.currentCanvasHeight);
 				this.ctx.setFillStyle(this.bgColor);
 				this.ctx.fillRect(0, 0, this.currentCanvasWidth, this.currentCanvasHeight);
 			},
@@ -67,6 +89,11 @@
 			 * 复用单个Canvas处理所有文本行
 			 */
 			async drawAndGetPixels() {
+				// 发送前：确保画布处于干净背景态
+				await this.resetCanvas();
+				// 超采样比例（提高分辨率再降采样，减少模糊）
+				const SCALE = 3;
+				const PADDING_X = 1 * SCALE; // 左侧预留像素，避免首字裁剪
 				let binaryToHex = (binaryArray) => {
 					if (!Array.isArray(binaryArray) || binaryArray.length !== 8) {
 						throw new Error("输入必须是包含8个元素的二进制数组");
@@ -90,25 +117,107 @@
 					return hexString;
 				}
 
-				let convertCharToMatrix = (imageData, item) => {
+				let convertCharToMatrix = (drawResult, item) => {
+					// 设备端使用13x13点阵渲染（保持输出13列×13行），但只在内部采样12×12，保留右侧与底部1像素缓冲
 					const charWidth = 13;
-					const charHeight = 12;
-					const pixels = [];
-					for (let i = 0; i < imageData.length; i += 4) {
-						const R = imageData[i];
-						pixels.push(R < 128 ? 1 : 0);
+					const charHeight = 13;
+					const effectiveWidth = 12;   // 仅采样前12列
+					const effectiveHeight = 12; // 仅采样前12行
+					const { pixelData, width, height } = drawResult;
+					// 将高分辨率像素降采样为13x13的布尔矩阵
+					const target = new Array(charWidth * charHeight).fill(0);
+					const threshold = Math.max(0.2, Math.min(0.8, this.threshold || 0.45));
+					
+					// 确保采样区域严格对齐，从PADDING_X开始，只采样12列（右侧预留1px），12行（底部预留1px）
+					// 字符实际绘制区域：从PADDING_X开始，宽度为12*SCALE
+					const charStartX = PADDING_X;
+					const charEndX = PADDING_X + effectiveWidth * SCALE; // 仅采样到第12列
+					
+					for (let y = 0; y < charHeight; y++) {
+						for (let x = 0; x < charWidth; x++) {
+							// 超出有效采样区域（第13列或第13行）直接置0，作为缓冲
+							if (x >= effectiveWidth || y >= effectiveHeight) {
+								target[y * charWidth + x] = 0;
+								continue;
+							}
+							let onCount = 0;
+							let total = 0;
+							// 采样区域：字符从PADDING_X开始绘制，每列宽度为SCALE
+							const startX = PADDING_X + x * SCALE;
+							const startY = y * SCALE;
+							
+							for (let sy = 0; sy < SCALE; sy++) {
+								for (let sx = 0; sx < SCALE; sx++) {
+									const px = startX + sx;
+									const py = startY + sy;
+									
+									// 边界检查：确保不超出Canvas边界，且不超出字符实际绘制区域
+									if (px < 0 || py < 0 || px >= width || py >= height) {
+										// 边界外视为背景（黑色）
+										continue;
+									}
+									// 额外检查：确保不采样到字符右侧的残留区域
+									if (px >= charEndX) {
+										// 超出字符区域，视为背景
+										continue;
+									}
+									
+									const idx = (py * width + px) * 4;
+									const R = pixelData[idx];
+									const G = pixelData[idx + 1];
+									const B = pixelData[idx + 2];
+									const A = pixelData[idx + 3] || 255;
+									// 计算亮度
+									const luminance = 0.299 * R + 0.587 * G + 0.114 * B;
+									const alpha = A / 255;
+									// 背景是黑色，文字是白色，所以判断亮色（>=128）为文字点
+									if (luminance >= 128 && alpha > 0.5) onCount++;
+									total++;
+								}
+							}
+							// 当亮色占比超过阈值时判为1（至少需要采样到一些像素）
+							target[y * charWidth + x] = (total > 0 && onCount / total >= threshold) ? 1 : 0;
+						}
 					}
 
+					// 轻度笔画修复：可选 3x3 膨胀（启用时阈值更严格，避免变粗）
+					if (this.sharpen) {
+						const dilated = target.slice();
+						for (let y = 0; y < effectiveHeight; y++) {
+							for (let x = 0; x < effectiveWidth; x++) {
+								const idx = y * charWidth + x;
+								if (target[idx] === 1) continue;
+								let neighbors = 0;
+								for (let dy = -1; dy <= 1; dy++) {
+									for (let dx = -1; dx <= 1; dx++) {
+										if (dx === 0 && dy === 0) continue;
+										const nx = x + dx;
+										const ny = y + dy;
+										if (nx < 0 || ny < 0 || nx >= effectiveWidth || ny >= effectiveHeight) continue;
+										if (target[ny * charWidth + nx] === 1) neighbors++;
+									}
+								}
+								// 使用更严格的邻居门限，避免整体变粗
+								if (neighbors >= 5) {
+									dilated[idx] = 1;
+								}
+							}
+						}
+						for (let i = 0; i < target.length; i++) target[i] = dilated[i];
+					}
+					
 					const lowBytes = new Array(charWidth).fill(0);
 					const highBytes = new Array(charWidth).fill(0);
-
+					// 按列打包，每列13行分成上下两字节：低字节0-7行（8行），高字节8-12行（5行）
 					for (let col = 0; col < charWidth; col++) {
 						for (let row = 0; row < charHeight; row++) {
-							const pixel = pixels[row * charWidth + col];
+							const pixel = target[row * charWidth + col];
 							if (pixel === 1) {
 								if (row < 8) {
+									// 低字节：0-7行，从低位到高位
 									lowBytes[col] |= (1 << row);
 								} else {
+									// 高字节：8-12行，从低位到高位（使用5位，剩余3位未使用）
 									highBytes[col] |= (1 << (row - 8));
 								}
 							}
@@ -121,34 +230,32 @@
 					let result = {};
 					let ctx = this.ctx;
 
-					// 1. 动态调整Canvas尺寸
-					this.currentCanvasWidth = 13;
-					this.currentCanvasHeight = 12;
+					// 1. 动态调整Canvas尺寸（高分辨率）
+					// 设备端使用13x13点阵渲染
+					this.currentCanvasWidth = 13 * SCALE + PADDING_X;
+					this.currentCanvasHeight = 13 * SCALE;
 
 					// 2. 清空Canvas（绘制背景）
 					this.clearCanvas();
 
-					// 3. 设置文字样式
+					// 3. 设置文字样式（整数像素对齐，顶部基线，避免首字裁剪）
 					ctx.setFillStyle(this.color);
-					ctx.setTextBaseline('middle');
-					// ctx.setTextAlign('center')
-					ctx.setFontSize(this.fontSize);
-					ctx.font = `${this.fontSize}px "PingFangBold", "PingFang SC", Arial, sans-serif`;
+					ctx.setTextBaseline('top');
+					ctx.setTextAlign('left');
+					const fs = Math.max(1, Math.round(this.fontSize)) * SCALE;
+					ctx.setFontSize(fs);
+					ctx.font = `${fs}px "PingFangBold", "PingFang SC", Arial, sans-serif`;
 
-					// 4. 绘制当前行文本
-					let currentX = 0;
-					let currentY = this.fontSize / 2 + 1;
-					for (let j = 0; j < textLine.length; j++) {
-						let char = textLine[j];
-						ctx.fillText(char, currentX, currentY);
-						// 按实际字符宽度计算间距
-						let charWidth = ctx.measureText(char).width;
-						currentX += charWidth;
-					}
+					// 4. 绘制单个字符（每个字符独立绘制在固定位置）
+					// 确保字符始终从PADDING_X开始绘制，Y坐标为0，保证采样一致性
+					const charX = PADDING_X;
+					const charY = 0;
+					ctx.fillText(textLine, charX, charY);
 
 					// 5. 异步绘制并获取像素数据（串行处理避免冲突）
-					await new Promise((resolve, reject) => {
-						ctx.draw(false, () => {
+					const grabPixels = () => new Promise((resolve, reject) => {
+						// 立即绘制并给一点缓冲时间，避免取像素过早
+						ctx.draw(true, () => {
 							setTimeout(() => {
 								uni.canvasGetImageData({
 									canvasId: 'reusableCanvas',
@@ -165,14 +272,22 @@
 										};
 										resolve();
 									},
-									fail: err => {
-										// console.error(`处理第${i+1}行失败:`, err);
-										reject(err)
-									}
+									fail: err => reject(err)
 								});
-							}, 100);
+							}, 70);
 						});
 					});
+					
+					await grabPixels();
+					// 一次性校验：若像素全黑或明显异常，重绘重取一次
+					let nonZero = false;
+					for (let i = 0; i < result.pixelData.length; i += 4) {
+						if (result.pixelData[i] || result.pixelData[i+1] || result.pixelData[i+2]) { nonZero = true; break; }
+					}
+					if (!nonZero) {
+						await new Promise(r => setTimeout(r, 50));
+						await grabPixels();
+					}
 
 					return result;
 				}
@@ -184,13 +299,23 @@
 					let item = this.validTxts[i];
 					// console.log("item=", item);
 					for (var j = 0; j < item.length; j++) {
-						let result = await drawTxt(item[j]);
-						linePixls.push(convertCharToMatrix(result.pixelData, item));
+						let char = item[j];
+						let result = await drawTxt(char);
+						let matrix = convertCharToMatrix(result, item);
+						// 调试：打印每个字符的点阵数据
+						console.log(`[点阵生成] 字符"${char}" 点阵数据:`, matrix.map(b => '0x' + b.toString(16).padStart(2, '0')).join(' '));
+						linePixls.push(matrix);
+						// 在字符间增加轻微延时，避免相邻提取竞争（尤其是末字符）
+						await new Promise(r => setTimeout(r, 20));
 					}
 					// console.log("hexs=", linePixls.join(","));
 					arr.push(linePixls);
+					// 每行结束再等一会，提高末字符稳定性
+					await new Promise(r => setTimeout(r, 40));
 				}
 
+				// 发送后：再次清空画布，避免残留影响下一次
+				await this.resetCanvas();
 				return arr;
 			}
 		}
@@ -202,6 +327,5 @@
 		position: fixed;
 		left: -9999px;
 		top: -9999px;
-		visibility: hidden;
 	}
 </style>

pages.json

@@ -164,6 +164,12 @@
 				"fullscreen": true
 			}
 		},
+		{
+			"path": "pages/6075/BJQ6075",
+			"style": {
+				"navigationStyle": "custom"
+			}
+		},
 		{
 			"path": "pages/common/map/index",
 			"style": {
@@ -252,34 +258,30 @@
 			}
 		},
 		{
-			"path" : "pages/6331/BJQ6331",
-			"style" : 
-			{
-				"navigationBarTitleText" : "BJQ6331"
+			"path": "pages/6331/BJQ6331",
+			"style": {
+				"navigationBarTitleText": "BJQ6331"
 			}
 		},
 		{
-			"path" : "pages/6331/AudioManager",
-			"style" : 
-			{
-				"navigationBarTitleText" : "语音管理"
+			"path": "pages/6331/AudioManager",
+			"style": {
+				"navigationBarTitleText": "语音管理"
 			}
 		},
 		{
-			"path" : "pages/4877/BJQ4877",
-			"style" : 
-			{
-				"navigationBarTitleText" : "BJQ 4877"
+			"path": "pages/4877/BJQ4877",
+			"style": {
+				"navigationBarTitleText": "BJQ 4877"
 			}
 		},
 		{
-			"path" : "pages/100/HBY100",
-			"style" : 
-			{
-				"navigationBarTitleText" : "HBY 100"
+			"path": "pages/100/HBY100",
+			"style": {
+				"navigationBarTitleText": "HBY 100"
 			}
 		}
-		
+
 
 	],
 	"tabBar": {

pages/100/HBY100.vue

@@ -147,7 +147,6 @@
 		</view>
 		<view class="arrowContent marginTop10">
 			<view class="modeSetting">
-
 				<view class="arrow" @click.stop="ArrowSet('red_all')"
 					:class="formData.sta_ArrowType=='red_all'?'active':''">
 					<view class="outCircle">

pages/6170/deviceControl/index.vue

@@ -297,11 +297,8 @@
 	export default {
 		data() {
 			return {
-				lastBrightnessTime: 0,
 				isCardSliding: false,
 				cardRect: null,
-				touchStartX: 0,
-				touchStartY: 0,
 				pageLoading: true,
 				navBarHeight: 70 + uni.getSystemInfoSync().statusBarHeight,
 				navTitle: "",
@@ -338,7 +335,6 @@
 				isLaserOn: false,
 				isSending: false,
 				isProcessing: false,
-				isLoading: false, // 主加载状态
 				isPolling: false // 轮询状态
 			}
 		},
@@ -557,7 +553,6 @@
 				};
 				lightModeSettings(data).then((res) => {
 					if (res.code == 200) {
-						// 只有确认成功才更新实际模式,选中模式
 						this.currentMainMode = this.pendingMainMode;
 						this.selectedItemIndex = selectedItem;
 						uni.showToast({
@@ -566,15 +561,11 @@
 						})
 						uni.hideLoading();
 						this.lightModeA = false;
-						//this.isProcessing = false
-						//loadingShown = false
 					} else {
 						uni.showToast({
 							title: res.msg,
 							icon: 'none'
 						})
-						//this.isProcessing = false
-						//loadingShown = false
 						uni.hideLoading();
 					}
 				})

pages/common/login/index.vue

@@ -252,7 +252,7 @@
 						uni.showToast({
 							title: res.msg || '服务器异常，请稍后重试',
 							icon: 'none'
-						})
+						})      
 					}
 				} catch (error) {
 					console.log('捕获错误:', error);

utils/BleHelper.js

@@ -752,30 +752,35 @@ class BleHelper {
 								}
 
 								try {
-									let receivJson = JSON.parse(str);
-									let key = "sta_address"; //HBY100以此方式上传mac地址
-									if (key in receivJson) {
-										this.data.LinkedList.find((v) => {
-											if (v.deviceId == receive
-												.deviceId) {
-												let macStr = receivJson[
-													key];
-												if (macStr.includes(':')) {
-													v.macAddress = macStr;
-												} else {
-													v.macAddress = macStr
-														.replace(/(.{2})/g,
-															'$1:').slice(0,
-															-1)
+									let trimmedStr = str.trim();
+									if (trimmedStr && (trimmedStr.startsWith('{') || trimmedStr.startsWith('['))) {
+										let receivJson = JSON.parse(str);
+										let key = "sta_address"; //HBY100以此方式上传mac地址
+										if (key in receivJson) {
+											this.data.LinkedList.find((v) => {
+												if (v.deviceId == receive
+													.deviceId) {
+													let macStr = receivJson[
+														key];
+													if (macStr.includes(':')) {
+														v.macAddress = macStr;
+													} else {
+														v.macAddress = macStr
+															.replace(/(.{2})/g,
+																'$1:').slice(0,
+																-1)
+													}
+
+													isUpdate = true;
 												}
+											});
 
-												isUpdate = true;
-											}
-										});
-
+										}
 									}
 								} catch (convertException) {
-									console.error("文本无法转json", convertException)
+									if (str && (str.trim().startsWith('{') || str.trim().startsWith('['))) {
+										console.error("JSON解析失败（可能是格式错误的数据）", convertException);
+									}
 								}
 
 								if (isUpdate) {
@@ -1029,7 +1034,7 @@ class BleHelper {
 
 	//订阅消息
 	subScribe(deviceId, state) {
-		// console.log("开始订阅消息", state);
+		console.log("开始订阅消息", deviceId, state);
 		return new Promise((resolve, reject) => {
 			setTimeout(() => {
 
@@ -1150,13 +1155,12 @@ class BleHelper {
 
 						results.forEach((result, index) => {
 							if (result.status === "fulfilled") {
-								// console.log(`操作${index + 1}成功:`, result.value);
+								console.log(`订阅消息操作${index + 1}成功:`, result.value);
 							} else {
-								// console.log(`操作${index + 1}失败:`, result.reason
-								// .message);
+								console.error(`订阅消息操作${index + 1}失败:`, result.reason);
 							}
 						});
-						// console.log("订阅消息成功");
+						console.log("订阅消息完成，deviceId:", deviceId);
 						resolve();
 					}).catch((ex) => {
 						console.error("异常,ex=", ex);
@@ -1547,9 +1551,19 @@ class BleHelper {
 					}
 				} else { //已连接过，直接订阅消息		
 					// console.log("11111111");
-					if (fIndex > -1 && f && !f.notifyState) {
-
-						this.subScribe(deviceId, true);
+					if (fIndex > -1 && f) {
+						if (!f.notifyState) {
+							console.log("设备已连接但未订阅，开始订阅消息");
+							return this.subScribe(deviceId, true).then(() => {
+								console.log("订阅消息完成");
+								return Promise.resolve(true);
+							}).catch(err => {
+								console.error("订阅消息失败:", err);
+								return Promise.resolve(true);
+							});
+						} else {
+							console.log("设备已连接且已订阅消息");
+						}
 					}
 					return Promise.resolve(true); //已连接过的设备无需获取服务
 				}
@@ -1698,8 +1712,32 @@ class BleHelper {
 		if (this.data.platform == 'web') {
 			return Promise.resolve("h5平台默认成功");
 		}
-		// console.log("deviceid=" + deviceid + ",writeServiceId=" + writeServiceId + ",wirteCharactId=" +
-		// 	wirteCharactId + ",timeout=" + ms)
+		
+		// 打印发送的蓝牙指令
+		let bufferHex = '';
+		if (buffer) {
+			let bytes = [];
+			// 处理不同类型的buffer（ArrayBuffer、Uint8Array等）
+			if (buffer instanceof ArrayBuffer) {
+				let dataView = new DataView(buffer);
+				for (let i = 0; i < buffer.byteLength; i++) {
+					bytes.push(dataView.getUint8(i));
+				}
+			} else if (buffer.byteLength !== undefined) {
+				// 如果是 Uint8Array 或其他类型
+				for (let i = 0; i < buffer.byteLength; i++) {
+					bytes.push(buffer[i] || 0);
+				}
+			} else if (Array.isArray(buffer)) {
+				bytes = buffer;
+			}
+			if (bytes.length > 0) {
+				bufferHex = bytes.map(b => '0x' + b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
+			}
+		}
+		console.log("准备发送蓝牙指令 - deviceId:", deviceid, "writeServiceId:", writeServiceId, "writeCharactId:", wirteCharactId);
+		console.log("发送数据(Hex):", bufferHex || "(空数据)");
+		console.log("发送数据(原始buffer长度):", buffer ? (buffer.byteLength || buffer.length || 0) : 0);
 		if (ms === undefined) {
 			ms = 50;
 		}
@@ -1743,13 +1781,14 @@ class BleHelper {
 						serviceId: device.writeServiceId,
 						characteristicId: device.wirteCharactId,
 						value: buffer,
+						writeType: 'write',
 						success: () => {
-							// console.log("发送数据成功");
+							console.log("✓ 蓝牙指令发送成功 - deviceId:", device.deviceId);
 							succ();
 						},
 						fail: (ex) => {
 							ex = this.getError(ex);
-							console.error("发送数据失败", ex);
+							console.error("✗ 蓝牙指令发送失败 - deviceId:", device.deviceId, "错误:", ex);
 
 							err(ex);
 						}
@@ -1787,10 +1826,10 @@ class BleHelper {
 
 		}
 		if (c.Linked) {
-			// console.log("蓝牙已连接，直接发送");
+			console.log("蓝牙已连接，直接发送数据");
 			return sendBuffer();
 		} else {
-			// console.log("先连接蓝牙再发送");
+			console.log("蓝牙未连接，先连接蓝牙再发送数据");
 			return new Promise((resolve, reject) => {
 				let f = this.data.LinkedList.find((v) => {
 					return v.deviceId == deviceid;

utils/BleReceive.js

@@ -44,24 +44,27 @@ class BleReceive {
 		if (f && f.macAddress && f.device && f.device.id) {
 			let handler = null;
 			let keys = Object.keys(this.HandlerMap);
+			let devKey = f.device.detailPageUrl ? f.device.detailPageUrl.replace(/\//g, '').toLowerCase() : '';
+			console.log("查找handler - detailPageUrl:", f.device.detailPageUrl, "转换后:", devKey);
 			for (let index = 0; index < keys.length; index++) {
-				let key = keys[index].replaceAll('/', '').toLowerCase();
-				let devKey = f.device.detailPageUrl ? f.device.detailPageUrl.replaceAll('/', '').toLowerCase() : '';
+				let key = keys[index].replace(/\//g, '').toLowerCase();
 				if (key == devKey) {
 					handler = this.HandlerMap[keys[index]];
+					console.log("找到匹配的handler:", keys[index]);
 					break;
 				}
 			}
 
 			if (handler) {
 				let data = handler(receive, f, path, recArr);
+				console.log("handler返回的数据:", data);
 				return data;
 			} else {
-				console.log("已收到消息,但无指定处理程序", receive);
+				console.log("已收到消息,但无指定处理程序, deviceUrl:", f.device.detailPageUrl, "可用handlers:", keys);
 			}
 
 		} else {
-			console.log("已收到该消息,但无法处理", receive);
+			console.log("已收到该消息,但无法处理", receive, "f:", f);
 		}
 
 		return receive;
@@ -466,12 +469,13 @@ class BleReceive {
 				formData.battary =  batteryLevel;
 				formData.statu = warn;
 				formData.xuhang = lightingTime;
-						
+				
+				console.log("7305解析结果 - 电量:", batteryLevel, "续航:", lightingTime, "完整数据:", formData);
 
 				let recCnt = recArr.find(v => {
 
-					return v.key.replaceAll('/', '').toLowerCase() === f.device.detailPageUrl.replaceAll(
-						'/', '').toLowerCase();
+					return v.key.replace(/\//g, '').toLowerCase() === f.device.detailPageUrl.replace(
+						/\//g, '').toLowerCase();
 				});
 				if (!recCnt) {
 					if (batteryLevel <= 20) {
@@ -487,9 +491,11 @@ class BleReceive {
 				this.setBleFormData(formData, f);
 				return formData;
 			} catch (error) {
-				console.log('数据解析错误:', error);
+				console.log('7305数据解析错误:', error);
+				return null;
 			}
 		}
+		return null;
 	}
 
 	Receive_4877(receive,f,path,recArr){