From fe60d656b17b15e40a8dcb406c7dfd91fd5b82de Mon Sep 17 00:00:00 2001
From: zhu-mengmeng <15588200382@163.com>
Date: Sat, 16 Aug 2025 11:50:44 +0800
Subject: [PATCH] =?UTF-8?q?fix:=E4=BF=AE=E6=94=B9=E5=BC=BA=E5=BA=A6?=
 =?UTF-8?q?=E8=8E=B7=E5=8F=96=E6=96=B9=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 config/app_config.json |   2 +-
 dao/inspection_dao.py  |   2 +-
 db/jtDB.db             | Bin 1433600 -> 1458176 bytes
 from pymodbus.py       |   4 +-
 widgets/main_window.py | 349 ++++++++++++++++++-----------------------
 5 files changed, 157 insertions(+), 200 deletions(-)

diff --git a/config/app_config.json b/config/app_config.json
index f1b5f6c..f49e74a 100644
--- a/config/app_config.json
+++ b/config/app_config.json
@@ -7,7 +7,7 @@
             "enable_keyboard_listener": false,
             "enable_camera": false
         },
-        "base_url": "http://localhost:8085",
+        "base_url": "https://jsjtnew.tengzhicn.com",
         "mode": "api"
     },
     "apis": {
diff --git a/dao/inspection_dao.py b/dao/inspection_dao.py
index 03d9e9b..89d27c2 100644
--- a/dao/inspection_dao.py
+++ b/dao/inspection_dao.py
@@ -180,7 +180,7 @@ class InspectionDAO:
             
             # 构建SQL
             sql = f"""
-            UPDATE inspection_config
+            UPDATE wsbz_inspection_config
             SET {', '.join(update_fields)}
             WHERE id = ?
             """
diff --git a/db/jtDB.db b/db/jtDB.db
index ea75ffd59cabefc82d1410ea30472c692fd987e9..fcdd03a60b8c0005060fde5aa474606caf40b34f 100644
GIT binary patch
delta 23089
zcmd6P34ByVw)fro_U$d*O{eK}Cm{(**weXNZvmA>L>YE*RP+skxQ)Po3!<W(4oW~l
zz$O%nOF$G{Ks15Ih=?<epEJ)<X4N<2%%DRjVK!Xm`9^0Pzf<>icW&Rl*+$>@`vQT!
z|EgQ()TvWdr>g$djVCW}Y`k(ypy;NZ1VJu=-)jkiptg<*Q#b8=;hK)~*=L7&=?f?{
z$xZqx>dWN#3x<=2lHa*tk9)VH=q$k&EhL=hIZrt6Ec#oUYvMUa*>}hxgvIT*SiA&r
zmBS+W34&X>Bz?Ri-SJeibk^HEly4);{T%1#rZGbZvP$_#5*|{?%Pd;4;<`n*ELwi;
zb?JTEyZ1LG?XzpD8?vSPIntpkb@}bf7GHPElD2DR?{jf$93>!tye4VC=5MTHn4`oo
z1np_2{B0GBKD7;jB;|)(*e*e?1?@xHYL<N{mhB{qZnU4WZLm%>zeBypeoD7n9Ht*L
z+lZay;bhgsJIqbRwPW1nW0U`VXiV}Kt-hr2e9%-U#DdY}lII^WH`R_9i&KAga4e)&
zCQA<eicVZvk$i36+_wK|{e}I-!;EW~&G{zCCKo&Z;rz_`vGdQ)F6W2N-#XuO{@nSt
z^G%TQOxs&0|5;>%Jc|-E{Cm~vwx7QvxdL&*If9<*c-4Nj?P}{n?w95TrqkqZCPu{J
zrG-PA{B|tdL)1F(PerMBq{Ht+WIbJ`s5<sF*;K~|Ly_d;f7so&?)0NnTkOnR<1LQk
zgyXpLN$0dwQ6+iEQGKb#!~{06<j*x+#>D7*vq-;R<i$`OAFUI@m3*v0<{PBwt#{sf
z+jYy3J4o)Lob~9ZpW4que+-gS8K`l|)=9;lt7&LyPlW{<og&=O(vm;9ads72Fq?Fb
z>$SiuDR|2Zz67nFee0*QhoNWcNw>$~t>!Q4$<!D1l)W+VIqBF&H4&c|{o4MRZN2qU
z#%`(LhOq}tlfh{JWnRmU#zsT$y-eXI^Cm0y+fu`hQ&EyNk5W>uenpeA_Z2EeQc@6o
z{9X67l>7p9fo0s3kvN~1sLq<b*5NPpc>Gm_!$S~$hhwzQS6bosdL4<IlJB&ZIl|%T
z^TiM!;RU`<KtJlBMwmrGmV!b!Ipa_{`tSjI2oheVMxbk7rk1CEeS#XdsO$hiy-$9h
zI8gK_$6NN4ZLf8$WeIl!{XgtiCIl5(XKwO26?NmIX<QK>GS$%%BLsygnovjYW_?BZ
z$$=mw^Fcn0<_78A-Vz5+_ViRD&v#ILJuTV6dBU>9%Y0Chk!vg+K+W~^ovCA$w8g%T
zr`Pe!I^J}YXPMJAZ%`i*;M*U9PrvRw;(Uru(6`Xn((~!5v`kmiLuiuvC{^q-uOL%9
z+~zCDxQni)6sv@IF<d7Gs`bEdJy4|wD)m4`5nVy4h8F6CfIt7SMEh7J1bo_OAuu%m
z(c8SmV@_@HaNEY9jr&~|^6w~kKDU68!=BF6#`C!|TUqnB?YG${r&gWf?qV5BCn2DZ
zFZKA*JM%mqRQWC!#(kg_O$vC&ntAqpcz6e$y1-qZdih;$3{6i~^N&usf5QnRWB)ZF
zLc0oR>ie7%JzQ)Z4zH6i{06+EQ@?zltEX!&p{^&KKXdMLu5w=N3>5vDDWXr)FVgqX
z-=;@UpHXj6+o|hO@o8>V>ao+@n`FG+R6TmE*2vT6Pnk1+j$)vQEaPs(N5tqtf#;(<
zAE+K={^9-PkLv|g_49&0f8`+aSJas*pu$-Phzr{KhNN8ad`yn<;ebCsdq25L29?_f
zxv$jd(of+-2UWNiHNI^fgZTgEOwBi+;ZirBv23@Q!M`pghY~FlE%VTd)7EizW*$>R
ze@4Ga?{fYOZK<?Wf_p7NCl6a~C|=^KNWINi7f@*Fr<S_Z|M}Envn#IVmSZA&mzDZ6
zF^~9!piWR*P-UZi6yi@igl~15kD1q-uP~2d|IWV2?qF|Zqbz57&vd}F+H|q0gz09E
zF%K|TQ;R8?V#)W&XUH|=EV7dLgb6YP{WE$Wy^6k=4uGb|L6^y@F1sn~@YJ6uYdwih
z2dp0S!+>=HnicR4LsJ>6fcsDoGLKO+-(3QkpC+y6ld1Aj>s$)mTVbt1^GdCwO@a_H
z-;CyzTF0g?HCqpHPSZwW4snz)U2Pi2{F8YLRc^7&LRU|;6~&#WoUP6k%p=TFW&&fU
z->09W*U&S-c%8&iwv}DMPGnuC)ATUvBkKFqHtKpR4AuD+`4qW|ya@Xw=#=@<cxaRt
zqIF`<<)XYKM--Qf3gLx<0NpJX*skQiO6`*ad7)*H0=A*n3hOoapZb<RSs#gmj96Wd
z^MO)Q<cj&qxEtoBh!6?Pse=lQ%xTn5?%9LNJu5z_>@x?Id&U4v6X!L?PY&P(ZT^Qf
z`6Ij(*4Qz^M?%{16Gl)e5Gl+b*9^FYFN6zU=rez4koo2Mg*`LCKx!ZjTmT=H<$#D@
z_gGKjE;=8&=p58~wa12CuFrlTiE?1KM$ka=?;3dixQqqt9QX@L{vCtNk2Lx7EgOe0
zFW)&7Qw4i{!6-i;7&XZJBeVJA%JkQ#w}L`^U_|zX0p_nAVE(ugPJn=#0lu)1kA-+S
z5*Rkf{N={^<C*wI)7>%x%8Xy=HGk<K^9PjtadjvKr;zdoj7T;Bi7gZ)ftNyo3Hbv0
z%|Cu1`Qs5WC!k><FKF_|2AMx<kU!oNVnSq}4KewcghQ@kgBSYB?-^wNA@!#3<YL~!
zCMZ<MJxBqrRC}@YFC^MD%=$4}UT&>IKNxCFrWTi5$C2^AW(Z{v5b~w<o1Y(4ep(LH
zAFZ@9r|4$$24w!o`aQ-%av!5rA6b_NxevJ4xSw)+xEHvs++1!Ew~|Y6lQ@B^;@liz
zK4<=&`MCKf=4Z{j%o}VUv{g;Kl|{?n^H^XwmtfIKH0Rb@QC^JIiNv~mKp^hd0<cFw
z+?NlC#9A#7fgDX*0IWeIv_J@e#<-KNCY5*v<jQqI-ZS)=d$s9eop6u#85V(Sw9inH
zyYrvLyYipqJM*7I@zojt$5MA_pP`zo@}I@qwa-w=+wz~qTXWCgpHSW{x#uu1LU}8-
z&yhMxSkdhM+?sNKZu{snGy7k}K5{LY;y$vA<WTx^`V9RJyNkUaLe{I;i&%jzHGhzr
z^RYcnp^imd5qj`|tIS(W!<tC#h@pi7NEKrK?o`p=><((EE=>|bqW?1jeYM}U5xw%6
zy@KSx6&Mmd|C!yUEQ8V6{Vpe3_^F+3w*K7?zYh2<N?HHz{GypXLZ2g?=g|3;<~Pu(
zM%RQm`y2Mh>`Uwc7MVm-mC40?#r&0B$KK8^VJ~GTgT9rl)ATRXUrf!WRi^7q^G#Ds
z@0<S9)M0wsw1ZjC+`(MWT*h3;NX&4?4J(Lq%x{^un3tJnn4OkOEMZHv#l?Ne{n6-;
z5}&t?n7D+>x-pJQ0=qR1rU1M2z)n4|Lk}Q5uw4(d=z(oL+Z}4S6G-Z_Jgf!4F9LJ)
zz-&D*OApM{12eJ!j!N)^6qt}jvcPyf(4YrmdLXI=pxXvSJs{|TIIl<Q^*~S$MD##d
z4}|o9tOukF5XZZ3I4BB?(q|c|2S(_DT0Kys2Zrf^avcy4l<AN_sU8Su0o+!_dcdOx
zhUfve9&o8Z>XUUYr{7HOB-+UP2;{nkn;s|cqiQJ^`46&_{3&^y+)q73-AOH>W>XE$
zKRJKpe2rd6Pp3n4C2fPvr4OjLsFd?L+n2UK+TOLjZhOJ@nC(H^YTI?TdA18|<7|E#
zYyH%E+WHe~hjqVon>ArwZoSHSu{C5JZgpDzX*p~8mE{MP!<I)a4_NN7EV0bB#Lu^k
zwUk&)+$Y@cxwp8NxTm-z*T^m77I4!z8Rn%T^FPep=3kn>Z+_nVh<Sr~mHArp9P@eR
zF=n5cVLxVn$NndKjD3=Qn2obb*(+iElVCh?n7%M|nSNn<&2-4L+qB+vyJ@j$wrPTC
zv}ve`W<G)u<i|{k*~e_1$=u7_%v`}tWkjX|b^$)8JL#X(C+UOqF1ne%jXFoYPyL8G
zN<D#h$dqw1`+qj5!TV+q=#HYEAd1jRf%C@kUYfENlr;lu4wQ7D5)+6<peip<jvU~P
za@K3XOzbTOf*Ldz4aSVXs0Pd_8ZiRHMqtS4CyKM1Ap|<`ncWr7EV=PAY*+3b4Y<<?
z++hSFJ*e!V7=bN4V5n!iWm^y01162YhtcRKT-(qadtJAn8}_=cLG^oGQN-<ajX)pn
zag9c=?s3(iXZE-}smAAAjkIS7J(8L-Be$y`ixe+T-TAD`M4}%(<9ZcMea3Y^`uWqY
zThY3wU9#d9imQyw$<FS(;+2>YSZf5<6o7c!)(9M~1y#3ztW{bxyX{+P1XkpM*%g`*
zSZ)NC<$>|c`=xnk1`Oyxb!*lLEHMIoMxZvVi7w>h>VB^_5CSx_BGJ9CEK@v2;1DCw
zZ3MbBAZ-1K=<fZlV)V+>F0)nzoFa$BP{4uyaKM#BiT$n%@K#C^wo*3ZfXnhNO{dwd
zDKpojCm4a_jlhPZhh5~!3Mk%AHW5W{JC534w6$9W?rrl<cCqOO>PyB-HbJbnn53Fk
zqt=yfU$LKX_#BzzEJtaD$Kz<a7HwYT9)Uhy={}zoL$bh&sQwnW#D=4MB+R45x454p
zt!U>8_XrBkKwewnehS@rkNbRT!BVtmrQ4ILzSTXAY`)=kH~bDs-Eh0-SzGG6lZuPU
zHh$tiXmo15mqD#ly<BtMI!~%@UGcjwG0)J82~@e28;UAl;K~AA2e+Tw25Xn)+*RDg
zT!=nI@21z&x6_N!zgoElRJoF~qwh@gejnX9so0)cI;nUFndB#S=gKzE&u)C;KAgW7
zI=c{>RS3;2gl3@go^;9R_!F+@n2_Z85!!zMMvkTXT)#{~b=C&R-+*bWxYX1ey~jsR
zfmZNSpApVgMSm{3(ea_<D*I3E(`-Mmoo7929cS5Vspj@_RpwT61-qN|njSJS%w6;s
z^lF%eZzDe;R}z0AZiM1qq-Mt3hq#Dpl5}_-%AxJ(v12ns5{~t3wwspUbQ_NR>-b2W
z7{zC{QmlcGsb{wO1oXjLrg(XzV2zA-w6C~W*(HLFEk54v?n5R`4_@Zder4X%?gE(>
zi*Y>%FR`j$i78joTTC(uy4`_Z+3xkB^IE*0(nPxrIdAutAo*eMjr6_kR`kJ6Z)xg_
z9p39Hnr*uqJ(h&5w>;wgJayA!-XaoRv)j8Ct$N)1K&pPb_el!<{!#A(!yM55HsULy
zsM!9ct;4#*a+&!gJC68@d6&M6x)gf<2f?Pfx9g6WBMv_tDEq7YlGl&>qz`^7pg%hj
zW2NM&*3x(+npq{QyRXn*c%?CA4lfF#v|t9$ckSQWwflkep~ub~JJ|i;3!U4WyAGaM
za0TpK3sQ)OgJC%6oxumi(Ah^HKKt-qQRbtfG-WCu`EbLNLL@YahaWf`;_If)o(KDN
zGJZ!4L82V0U2sJlmosO69moyBu!fUDuwEBK)8}7!IlLJWa`LC~!kRN3`?}lrceWfp
z+r0VAu}$d{sQc*s-LE#M5AE$-pGt38pWd=jO+9yfWBQ@TJGbxb+I9dmym(4w*WR}D
z;mv0{9s-?3X^pB_ah_&PHLJ1xl3U-Xp%Y{kHjr06gNI!Nz7CX9>?88Y@BJ`rm-!GM
zib<d(A59+q;mRp%1lUQCZ@!_v`;~STu7@f#Ex04^$h^us78<48TLA;5*YATyiTHek
zzYYe<#I<nlABcy7e6~@Pa}~8wV$<heF$G(bkK%Ue+<v$dJ$W{nICCrsbyQj;20<il
z5g|Nd)=h#4$M8MbrbeOy?3e<CZ7<g1O!L&Yx;l<^?m3!XcYpfCeV})IOpNDe&IAUC
znjflN2UYES@DZ?Idfjt%T@M|GRtUp}wahE6a_nGd<NnUp=I-a$f!(2Dy6$_R^Pwl<
zbLWE_&K!I6Y-3|r;@R}Z#<Pu&D;W-+MeSWp8@dkdId^=0dUr?q(602xj`ZV@x*>g$
z@=1NCbKB9bj#t;H$~VnhRp{QO19opX&(gRz&=dM`Z*0t*e+%J3__q+w_;+0CCmH`1
zLJ=Og8xY|BKlAVL`8{u~`!<~cB|JX(Fa;$uXM26>oV}I=SF9cig8^(tWepd>;{xob
zB{zRqRudKEth3>2h0-VPhh_u|hXj7gR6)RCvh_eoSy)NF_@X+V7eeWdRC@i>-6u|j
zVQC#w=Kg2S1D^nINN-N5!NHofLvHO)PoIIFaEhunu%c&7jA1=%qXKkLwNrp1f@q+p
zASU-5@Rh^RhcgUD)24~HU`?Gpd>F}5;q$;?3!R%FDu7-EnpV`}5jT!IcbTjxscz!s
zK4QDZ<S^*#i(h!jEFr|#T{KmQ$U#w|(Fl^NG^i)#l5-yb6|rYYk~(M#e7JMR<Iv%{
zHoOEQGVY=3_}IC5%b63qVQ@+x+yW-=K6JS2g*Gu9l6m+a4_de#uIYF+{mA<CzWp##
zhL<e^DD(28Pr_)b3@Hz8=x%Pq0+%g=zOHuEKQuP2(G<807uQs=(x4fW9~>M?da-wT
z)vZg#3izYqUD4!2A676z7?^V3I<%>w`}vm6))Z*b+4$s|rim+b1p<Z2r=w8$R0`G2
zAfc>0L!pAwvu=z(s)7V``bu}PS%B^cb;(hx93md}ByeL0hGaDHWy*&MRwJC9N1y6^
zc`L9IyPry&eRc<W`emxL0-NlK1L^xy0Hz<@*STr$n(jRZ&OW*~egB3t9fwk1KIb*l
z!yLBNg!6!NZqesOdyA$x&NwzYLiXR<@3oJxy<=MqQQ5a`^!&tFH1{Aibdo}p6NCm?
zY~Z6oAr^z?ovwymhDrI{f%%Cs`Nc?bgD3~(Ffhkrx?=K@@`?#xmKcrpJV6bOXGIEP
z1JD;^A}|3YT`_q{dBue2s}rMK5V%-~NzO^-96^jG32jyQ1|ixYgn|N?Th^<GZ7^I6
zLid$pFbOT3bm7cPX62PH(w8MhDtb;<^n_4Vgz`iPBf?@dtkqMWq%B8^Q1cTbu-Qs3
z5Mz~s)F6Oju^{ve0Rp64$Xl3{D+MOQh;&(^7AxbwAX*6p@Sz4d5`?}Sj%77b;%R-7
zwhUROu1?gTzl0e7MM~ry0=6V{x{w6!*rSMAezZXhL-`VnSq0WnPLrXmY9vg^mL-Q8
zB<NSX9EG7GS1Cn|9Bq)~U__3}F&OQ2md0gCV4>j|3#m(jD6SpQqd);&VUjjUTe}c{
zS)xj@5c0n2J;$^#%Lz2*RB;2Ec-Z_cwCSYRV>RDpzTP~~e7<=MT63znqI{^CV*kqi
zntg+v#Wt`b*deBWu`jZZu@A7T*v07BN6t~G^`y6^n0veM4|J?iuskerJMeiF92W2P
z(4*m?HFI{TV!I5mod(zr0}L5p+YPXmxB<A$081KR59=`r=r;z~Yy)go28*i%K845=
zm}!u4Mjobkb6|o2Hr@bhFu-E@7#t)-q(C$u#Ds@{Xn+X@7;k{p8(={LEaHi4+g<4!
zfv`cwkO3weV3Gkg$^aXg#o}51B-D6B7Sv$123U<A1L{n*0XEzKtI}a{AZ`XKbs)wn
z^cW~O%m6Dlz{(7;QUfgDq2rovrwk_ne?dkmP-1}j46vaFn707q1I0OP+8l@sv0y&n
z$$>rC5ChC@fVol~Z+fSj=~1?ilIBx$+lCz8VT=1(fTk#M+G!0YE}<b5@wL<$r-;6m
zafK;Ts38>fwTv}R5qvFU3{s?cgCzM{MjItHh@ir#!W5W+uyP}fQ$V>9`V<}p`vwVA
zs4Yl|Hwcgfde;;rDJk$$wLuC@j_?k!mGdnJ^DfL%kW!^ff%!WG_JPtW^Hbt@gDNCL
zs;{LYKS{Z65Q42MU&}D#6sT*tL5kE6f_KV{Q)FLDsU{`fbFYC9`&t5;q)ZCzo?*TH
zg()H^2MtkTkRmn6P?|3<MW_VhWb89En-W*9RzQ;6fG2n`oj04*lahI<Sf2t?)OS3E
zDMDDW+>oA>NS&mp0BTF19GtB~<Hh;RPN5PV;krVNT-uj%A(aG8<jhM^1DS|o?jl_Z
zG%G|B*rpES6yDcjXNdZ&1LZa=!55(QY<Vw*aa0$A;v#6r@4Yu(=wMzT%E%g$O|c<U
zyNRdA6n$EBv-568+J1@slw*PIN49C!A6lnaUb9T%Uggd+zif^%0{uL7fEq#WgBL4^
z9kAzi`r>=qrQS9f;oMla$%w;B2n?lytyF<WTYhWu&CjO*;xj=Ut@P}p%JFuww|!I)
z=WrAX<PrI(!^5hUMv0M(=iABzh{vlOk6(smsZNg2ha9{8o0G%$A*Wz38e6ZRJ`)E}
zp9I<Na}gCJ=`77{dMi_c0Bj#Lsm1H5Py=Du=?)h(4<2FAsRgtb8Ys)h!)HPG)G6O^
zQoOysj|vrRbQ@M^{s1a;PkRvL7;bJG`dy*fMh-v<EZy*>vAbs_i1wk1{Tv4Nqv<=Y
zyXl4-uUn#9RP=32*ud|{miM-MK_=AEK<2+A5soSPkr;0;?ydD;H=v+<;UVf9I2!Tv
zA+w;X4M66yeh(_*?XWC2J_71(7=c9{U(hiW_Z94n7es2A?fBR_zhl72HL?$p1=YkQ
ze|?c7`VeV2xO{z)wS9;*?EZa=yt!Y)-qT(KA_p-N^eqrNNxv;wZCFS3N?t)HQCpHX
zcAh9A|7wEs!-9KddEO&~_YChtW-s3JwPjZIA+s0v`Pwoo`;gg-|MV$yX}`9;r@aDX
z7CMmHo(3~Lgi(F9W^KO`;efOZACQ(HcP%rtGP~0yM+ycQJoCno`^}=_TCHEIERZ}O
z3CRhzy<9m<Wie&XZb!m4Tk*gOkN01=xqX<@GQOV4D7$~J44JU&7!EC6wD`KE`gsuc
z@OrCRgRCB_BmbL4_5sw8YA;2>JG?$pLW?Fd-fygOOuJv1-Mu}P%SA^Hhad%|LC&`@
zddq5KPM?q7UqD;H!u`y>38uZIS0(IrP$Kqql>iI(rv%X+z=!qN!Y^FOcm`(SCH=Y&
z;eZQ_CDazqvD*Hb{WjYtw&m7t>mti<ESGWba+jOmHDAuYYkIxt&!z_Ft?cxo>*-c%
z3-dfPlH8p6!=h_isY+nH1gUs}Jp%0o^S7qG6lYXv!gjkD3P$pLF}sZ~OK=*X?PZ#T
zkeF>T?FOl`PUxW&;Xdb779?=_7xq*gUl8jcLTrjB=p)d4ppz!T*63ujiT`^Ffj&Uh
zRTWAwM@p69%-A+SYmj?YByao~oMqx-&k`!5i1|psaKum>$>D%wnb<dG6ub=2UPFW<
z=G@Sj(S<#t2DZjVQ5>chRp1mVkNTrAi;%Gw7KXkmVNL2byVhfXdZ|~1I+CFu^^7$d
zKcQ*k))|l*=*tq;JRl|LBe0x-InQILgeVBTX(9C1dveA=|14p-fhYlsEBLvmeU9QK
zIhN8$m5l{n0_+cMG^JP`hyURQA#aUpkPydKS2mcHJ^wtyT3&-lk$c)__o09`v@(#R
zuJ{TQ;>!l3z^pzL(8gJXa+dX?K>WHvDKN7S1++oefE9?t*P9I70(ZC100lG=Se_5`
zL|_9Je;Yp-@d>JZf)Z9x62ui0Q_SGKJap=J4zF1~^AynBeGG(P1-B7%z7zo-R78T3
z#^*{pS!DVeCDH8-N{9#(@yfKx`*l=`WmRfP&|gC%qCKjF1|^s#nKwSb)}yh-ZtmA&
z@%Bi*@AZ%|ds&I&^;EArh`QyX;SOTB4}se5o;|Jp+5$s;2-J4(Z%m-vhd^z29+1Gi
zuw1>Uk>~Xx8AkD?Xi}r?rZ{y3b{X-$is7`<+uZg|#AHfHc6nyDr;n&xO1*_*`QEFH
zDjC9w@l=mKE@3?bnbH#GBd}!$2GFmPG%=6-Zw4CZ?<K5#igIY*cZ30CD`*iL86%3`
za;&n~T8~>^<L)vKGyR0|Qy-8qpaqnY^=oSqw2n<w2VcnK_xk-rt=EIuvg3g*TZOq>
zO$%#*4C;q3eX{%qP(hV1D!}1ZhO`tCBbZB=K9NfAex<H+`%6HPg)KPDt`vZNrqBq5
zpd5+-DNf9AxkTV?$UuU_RS{$XD3>@5E&8r|cyhtB)#xWx^moSdwU}SD?EsKHReDxu
z+kwveHmeMyt`|{P+s?D-(Am8^FhT0YJ)MtiNUwkR%<+A|#zI?m&^}oyxJgb>c{Q!V
z-}vSC`TW&HE#{soUp)nN$1JsqTurZs>Sb9|_+yrT8V=*io_VFM`~DMkzzPORFs>=Y
zOmZxy5bfsQq!4*k(i-OENuoGuG7mxNrBH1?9PR3OPRRi@Nhx{WK7SlIE@B8I07p>j
z+>|=oxGShKOE;yrJUiuk<1pEG%d@i<Lp{4Uyx7_H%9&%0-OZS=)`?oX_B;n9Q(#+R
zs_DyH;a|XWEYvkxscZQJnP&>+%g_8Jz}PF-w7RFN7T;UA6We0=0;oI;#hDmY3@hxh
zNJ!J-=||RONYQ*qR9ai5?S)kfOc(K$hfuDu<uKg#0(PX#BjGZ4l{Ex>Gayig>LMsn
zL$8nHS}E;(=A{SI8#bjkZ%TJ;Gi-CHWcS)vw9UQ-(*nbMB@}k^4Yy|93rlR8nILpk
z2X?p*YF<??Y1!c{W+MA^^l&)i%UK`<7U21?&_91xVTa?U&5~zf_>4^ga=4}P!wvf+
zS*3@Epkrj{;qa9XI6L+Wz88A90Br%DqNj&L`~idCph@Cg+a5pDu|KTzu0;3Yz3^A1
zhAT=%RMI+V)pTXtz<8K@Ts~fFJZ!u2@%hwxd;vY{Ju>#5{;BmaXehQbWY%kq2N~gB
zJ^Yj9*T;Ygsu&RZ6j;!JU;oV-P_@~)<B2>=f(?PIZlGM#h4=Pm$2=#*cBJ(_2w_*&
zj*`*~!(u-^2wst;{`NQ_9~MKCr}81K9r>sfjpb~pTtvt?VIGIOpF0ZwrW59DsJdRh
zD&rEX@4;UssrlkSU~Mb?R^b?{^Au6x2a`?1v|1;OS8x#_Ybi1L(A%}8QV<A)xN`|G
zO({fe7?ae#n0)K){|Gi+zXrF9=8OGC!xRCNVL4Idt;kFfzG^RSmphc35oNiX5paT<
z6(-<j35j8}HAVT7E8etvB|O$;Cp~2(6ogQcf4vNCewA`3%ev>fVRlRJeGEpu^!+c0
zLVC-A<ev1zx><J*NFh9DU8++EzOW&y5U(f{jVcP&f(fugz+9}TC1?j|K88~>cR4_V
zDA4tz$_0)~?=se8WWH&PHOZ3FMOBlmX*T`PTA62>D=(an@6HJPg}gX9qe%S+L$g*Y
zOaA8jL9CTCtCeu4(vgyr&IIf@P^kvKxkJ6Rq68{la09*$=3F&UQN+V#yDcfoKLW=j
ziW%@_yj<%*C?dnH5%8Uyd|z_r>(`E013M9-pugCHgDl4S1ES~(N1dIr{s6+NHfykH
ze8Q|K)<cQMByDfr_gs2QOEE(}u@aNC=VeIR5ZU!KoTTUr7lxE+cGE*=pLi_2E(O;~
zl%NXcvs}NHa&wC)hVk42<Zbl32k4>k43Qf)=3(-ZRa(E;xf9sh8}K{<7go~EaA9TF
zw8{1JWiWo72tA^*vT{_{Ll445l+H)DbhjT!Z)#CLK&P5=ix9yVYi52=1aIv+xIw*Q
zl-{`g>@yqF>o%!FAfCQk;g-~p6I~A+?QBedgv+N~xTa}jf>o|F>ImyuTU?TF3;b;<
z*|v)*gPouZcIg6JsEw&~Zdqds8HPBx0wk-pkT9to=*+#?qO!B~Sl6~A5NfK?Q}4C`
zdw^|l^_3eNmEc`)V+*1?2`s17yP(>pv2OIlO1FE!70>lvwc=4F(&)3|S|`X<d|*!S
zzgKZsUod0cqw@ytfiEy}CQxog{C~T^a4QQ87zpqW34fQQ+$X7X&Q#?|>a-JX(ANH6
DEo@X&

delta 3178
zcmZ8j3tUuH8o%e9`<{E}-eKm7GoTC)aR7lCUP_vfue2<!Oj|Ya#byeInEcdi1$=<L
z79Hh7G!sQLbxj@hk{aQz+pp4;e593bn21Vl;-;u=)}9e_vvYrE=A8fe-rsk>bBl}r
zRNOGC!eyQEFvFm6%)PPHlYyr^ykq>{zI;trgJfZN#D<(0-}d*;ibAjX$7R*nG*$C5
zyn2&SZ))}09P8zPo_$pfmkfp(qe`hxh7l(e6y#1QoG^V-?uFXQOYfHY!=5}6J&+Ay
zP#32tIz`0T(Op7z%7ntn({pFeyjZjK!rqO3=dhRvYRV84>69oPW^5gFq%e2pi!)yi
zO7wsJM0{Y*u-A2Qt{OvW(P+Oi{yHq3jk^ZAPPlIIC*_3%V)DOB315$tRC$#&LbPzz
z%zCyS&F4>(6*$NGgL=pxnOzb%z0RWwrS8}STSSE4tV!?}oe%TlbzcglTDSNhwsvhi
zRK}4I|GBkET&mZb<n=phR`1-->fw@hJg9t(_Ft`CyQW>yE^6OtXSLH5Zl%Jv1`ap;
zY_()w+*{XDv**I%MHd3ckEZIbMT{1Ulhu!uv6iuNj(AcS%{4KL*h~^lnQ{ZG&aJ^h
zsa?5i(Y1!e$|Pci#AKrSGY)(bc&PbMZ^>$7w0+u4E!niX(KglZ&3+baNvN8o=44SJ
zy`eP;4UF$cXteDS9Z}ToMRDfryq4vAF7Ey4a@k*}&&r>eTSzYD!&AeMD|ry6^fsp?
zIR*4v)bZ@8l=edX!VcQ34^{?8wVa=i;oC&y?9m^EFcMWFIT2!vj@;)@o_lde;NtS#
zm#g-5@X0Ah-b>EE%TYNTv1P0mnXDJ%Vpl7Y3)N>WUs%7E=81n6d`v5Mhy9tnj@{Ie
z&q!%%5?q^Vd(<4c3uj5n*zUow7)-RPI-%x6>`=PJg@%SjI1Qs)$&3CO=R@ro8IO%f
zN%!{j`n-w0mereDmQ+FOhd5S9>*-5R%1njGEk+lsFYQvzrps@yyRc|U^WJT6v`eQ@
zc%mLhD9v?mUS3{)dD*(=y0_u2twt;?tH*<d1t>14xpD_ifZg##hv7gh=HokXFT`U{
z@CcUdeBkWFPMnF%Z|ZTvgz!4X`n~$4a=@}xep8w)P7((2-8c_ZM;h>R)XhrsW;Br$
zQW~Pc4@qPw{Ol$kHjUOAcp}Lv9AfQ&J4F!>Bqb6Fr=~)3BngAbQDhDdQ9F*k(f5vF
zVl-K?*h?0B*~MONkC$hg^!=oQp+)+gc3eBC?bbG$9$hFvR#Nf%$6RI;#-aJa*kyPf
zNwl1*`VYMyP6{Q4knZ?Fs0XDgd=N^YP|kx;JcWin2*pt-^Fhc%q1gVB52)-;G5dpL
zv1Ju@!K|>0%j4zr9A8gwsxQ-d36lDXquKOS`={m`eZ}Ubyi%m}<Mx|HjpAIM6-F{X
zxb}?Q2}hr{+rfQG%pg(=17Eyj?+V^`9g5U5y_a(yRdy5_vuw%czEfg6AzycJ#hJEm
zL?4pqaZNH89hU$lNOnO^F41^l8b#N_BQ7IOO3O^)=hB`)n<m|wC(nq<M9*UTFxoM#
zRx8p5YcA^*@HB}<R<_UYAG4}SJc8&8j5fmNb7BHV-9|+n%UHS`1dWYitl4%<?24eS
zNlZjOC_W;`gZGBWl}&3F&1ub2rA5$=F#||7vm#r18VZ`^9#HO9;$gd6GGKmZy(^dQ
z_3~#rjLW(vm18uwWAl$6B~1zTk0hvZ8J-^eS($G7u`Y)Hi9gJ*;S2bFyn}1u>bTdq
zv0M_zu*cY1wul|fy1-qmc);7F`Z6yGbwauDoZunHNG&NMgNX}Y!S%QTPsC}MN2k$d
zG!G3$;mj3gKUHvlz($*V2rR4|Wj;#ezQ_ziaw-bimH_*(?7O=nzqfr1=KhcgbEF_|
z5$98x{m4N^D^R^EqckdOl>#MO(Jf7u?UrK8a7&bYUH(|ElBddjWUJI9?UWWuBPEac
zlXzHMBNmALL<hT&9l^$s>*SzyxYez;sSRp{I$nt3uk#1_<yy9;Tbr!gt;PIgK8<I&
z6I?C#GB<#8u+8i)MQ9dw2@8c0TBEi$5SiVJK-=?n6~1!F0XXcClaa-2aLNBh@OBq@
zH*B)WpZ>w`QUr-e4mTIE@>AFx*Hv~S*cL9g!D~pi1#3>>QhcdG9t^U{<M+5_wvoIf
z*+6KMUxK-9@^oxDNA)I%WwzV0X}fJ{YZu5-W+hs{m|~lff;#cl{34prG5jFj$A<|+
zgft;Skj>%Ol=+zD!|vT7Ti@3uGxWN`QtT^cIqg#w5X7LaU5P<ms0t_Q07n0)SjyyE
z3Y{vQR#U#E{Zz)6^H&({D)e;=A46lY-bay!NEuSJq>FdNR?2>YgR2XujvI@0#W{*A
zVm6>^BrX$Q6{m>Lh<(L4(INaQv<fGM24Ra(DU?VPq@hwzDN0hsTjF`~bLo8{Pg*T4
zk&5JKS(olet<ov!pu9<5A(zT8$z$aqat62`aX3J)5M7v?1bM|FlhPZ|-%txWjumtp
z55y@r0@vcD_%C=GevWh^1h?U{_%m#hRivEEA`{6l(uc%R4@3u8OF}yHY@WDRd>8Z@
z(F5)oqOOad->>7l3z)S*kA|ELdMspa&^=%Tw_nxjnJ~9j9}iNkJ_8o4*B3#1e`5=q
zmSJy!Lj#PH@X!8+SMp}|bWEggd^?TMf9?g?woP}z)td?rKWx(z;M`5cfo=u=q9LnY
z;ZZyI+Lbrp?2k$~Y#3m~c5;veoZ<~$gDDv~zLd1|lysNMz@yuAKb+d450LMpR><9=
zmqOcSeIfWZ>-F%^dwRQBxj`=_d$#MSA%dOCC=4*xBkCSyr)8Jy6ORZh`H9>M3=kEq
z0iT=9MlAeVXp5!&LwyAfe2ByS?)4HpIny>D=D%v|h4b>k*QJv^)Ci@YhH9wFI8~M2
z+iDp7(o;(({h#H;3|kiGP4Z=?L*yh|D5MwCpH-WT&Fs9=(Ro234*#glHZ$dATY9it
zGIwZM-Y$D#mW|F3^MzUVEtcJ%=^6)(<pv9DN<!qa<i&O~d9mZ<2kaZ%Y6jfdj;Q;&
zQ=mHA_&ep8$KK<pk!5r9Kx2*zouLVc6wQHCjQ!nH@oJ_M?#!s)ijN5&3)%b!e6m(#
z$+5OsUsTR1qvR$zNBWoaym$t8=HBC?NHx(ZdozMnmBvEC#xPLQsLx<a_+1*btuZ=7
z<#OW|E1qC}p$`0HzO}-zBJ<d4qZW&n^NbiQBQpYwg%}R5G8PbZ+I<0mSHN3sgu#K8
z#tlNreiIy+78D!?E8a1tu_Yuh2ikry3^-bC+<?KWjU|doiLr8ru{xAH)V6Did1tF3
z5SdtSGukHYDeLV(<o55a<k^x)s9BGlV0>g;Wygto8HjImJOtU>g~#E|2Ez{414azY
q`@+#0@MbFlG<LRW=BJ++y#<BUsu-<BJFM;0s;IPb4XVC1ru+|Ya=$MC

diff --git a/from pymodbus.py b/from pymodbus.py
index 37c95f2..340e121 100644
--- a/from pymodbus.py	
+++ b/from pymodbus.py	
@@ -2,7 +2,7 @@ from pymodbus.client import ModbusTcpClient
 import time
 client = ModbusTcpClient('localhost', port=5020)
 client.connect()
-client.write_registers(address=11, values=[12900])
+client.write_registers(address=11, values=[25700])
 # client.write_registers(address=3, values=[0])
 # time.sleep(2)
 # client.write_registers(address=0, values=[0])
@@ -13,7 +13,7 @@ client.write_registers(address=11, values=[12900])
 # 贴标完成
 # client.write_registers(address=24, values=[1])
 # client.write_registers(address=2, values=[0])
-client.write_registers(address=13, values=[0])
+client.write_registers(address=13, values=[1])
 # time.sleep(2)
 # client.write_registers(address=20, values=[0])
 # time.sleep(3)
diff --git a/widgets/main_window.py b/widgets/main_window.py
index 2a1c393..dbf6a46 100644
--- a/widgets/main_window.py
+++ b/widgets/main_window.py
@@ -77,6 +77,30 @@ class MainWindow(MainWindowUI):
         self.corp_name = corp_name
         self.corp_id = corp_id
         
+        # 初始化已处理的工程号集合，用于避免重复处理
+        self._processed_gc_notes = set()
+        
+        # 初始化加载信息
+        self._loading_info = {}
+        
+        # 初始化数据加载标志
+        self._loading_data_in_progress = False
+        
+        # 初始化表格更新锁
+        self._table_updating = False
+        
+        # 初始化当前处理行
+        self._current_processing_row = None
+        
+        # 初始化当前订单号
+        self._current_order_code = ""
+        
+        # 初始化当前箱号
+        self._current_spack = ""
+        
+        # 初始化检验配置
+        self.inspection_manager = InspectionConfigManager()
+        
         # 初始化焦点跟踪器
         from utils.focus_tracker import FocusTracker
         self.focus_tracker = FocusTracker.get_instance()
@@ -127,6 +151,9 @@ class MainWindow(MainWindowUI):
         self._weight_stable_threshold = 2  # 重量稳定阈值（秒）
         self._stability_check_timer = None  # 用于检查重量稳定性的定时器
         
+        # 初始化工程号对应强度数据
+        self._order_strength_data = {}  # 存储工程号对应的强度数据
+
         # 设置窗口标题
         if user_name and corp_name:
             self.setWindowTitle(f"腾智微丝产线包装系统 ({corp_name})")
@@ -951,6 +978,8 @@ class MainWindow(MainWindowUI):
                 if response.get("status", False):
                     gc_info = response.get("data", {})
                     self._current_gc_qd = gc_info.get("qd","")
+                    # 保存工程号对应的强度数据
+                    self._order_strength_data[gc_note] = self._current_gc_qd
                     self._current_gc_sc_gch = gc_info.get("sc_gch", "")  # 保存sc_gch字段
                     # 先获取当前 info_table 已有的数据
                     order_info = {}
@@ -1002,7 +1031,7 @@ class MainWindow(MainWindowUI):
                     self.add_new_inspection_row(gc_note, self._current_order_code)
                 else:
                     # 弹框提示，获取接口中的 message
-                    QMessageBox.warning(self, "提示", "获取工程号信息失败")
+                    QMessageBox.warning(self, "提示", "未查询到工程信息！")
             else:
                 # 直接添加新行
                 self.add_new_inspection_row(gc_note, self._current_order_code)
@@ -1118,6 +1147,16 @@ class MainWindow(MainWindowUI):
                 # 设置单元格属性以标识其关联的检验项
                 item.setData(Qt.UserRole, config.get('id'))
                 self.process_table.setItem(data_start_row, col_index, item)
+                
+                # 如果是强度(qd)配置，并且有强度值，则设置强度值
+                if config.get('name') == 'qd' and hasattr(self, '_current_gc_qd') and self._current_gc_qd:
+                    item.setText(str(self._current_gc_qd))
+                    logging.info(f"已设置工程号 {gc_note} 的强度值: {self._current_gc_qd}")
+                # 如果是强度(qd)配置，并且有工程号对应的强度值，则设置强度值
+                elif config.get('name') == 'qd' and hasattr(self, '_order_strength_data') and gc_note in self._order_strength_data:
+                    qd_value = self._order_strength_data.get(gc_note, "")
+                    item.setText(str(qd_value))
+                    logging.info(f"已从强度数据字典中设置工程号 {gc_note} 的强度值: {qd_value}")
             
             # 包装列设置为可编辑状态
             packaging_start_col = 2 + len(enabled_configs)
@@ -1145,8 +1184,35 @@ class MainWindow(MainWindowUI):
             # 只为没有自动填充值的配置创建空记录
             for config in enabled_configs:
                 config_name = config.get('name')
+                # 如果是强度(qd)配置，并且有强度值，则设置强度值
+                if config_name == 'qd' and hasattr(self, '_current_gc_qd') and self._current_gc_qd:
+                    data = [{
+                        'position': config.get('position'),
+                        'config_id': config.get('id'),
+                        'value': str(self._current_gc_qd),
+                        'status': 'pass',  # 设置为通过状态
+                        'remark': '',
+                        'tray_id': tray_id,
+                        'package_id': self._current_spack or tray_id
+                    }]
+                    inspection_dao.save_inspection_data(self._current_order_code, gc_note, data)
+                    logging.info(f"已保存工程号 {gc_note} 的强度值到数据库: {self._current_gc_qd}")
+                # 如果是强度(qd)配置，并且有工程号对应的强度值，则设置强度值
+                elif config_name == 'qd' and hasattr(self, '_order_strength_data') and gc_note in self._order_strength_data:
+                    qd_value = self._order_strength_data.get(gc_note, "")
+                    data = [{
+                        'position': config.get('position'),
+                        'config_id': config.get('id'),
+                        'value': str(qd_value),
+                        'status': 'pass',  # 设置为通过状态
+                        'remark': '',
+                        'tray_id': tray_id,
+                        'package_id': self._current_spack or tray_id
+                    }]
+                    inspection_dao.save_inspection_data(self._current_order_code, gc_note, data)
+                    logging.info(f"已从强度数据字典中保存工程号 {gc_note} 的强度值到数据库: {qd_value}")
                 # 如果order_info中没有对应的键，或者order_info为None
-                if not order_info or config_name not in order_info:
+                elif not order_info or config_name not in order_info:
                     data = [{
                         'position': config.get('position'),
                         'config_id': config.get('id'),
@@ -1187,35 +1253,28 @@ class MainWindow(MainWindowUI):
     
     
     def handle_inspection_cell_changed(self, row, column):
-        """处理微丝包装单元格内容变更
-        
-        Args:
-            row: 行索引
-            column: 列索引
-        """
-        # 创建唯一键，包含行、列、工程号
+        """处理检验表格单元格内容变更事件"""
         try:
-            # 获取工程号，用于创建更精确的唯一键
+            # 获取工程号
             order_item = self.process_table.item(row, 1)
             gc_note = order_item.text().strip() if order_item else ""
-            
-            # 创建包含行、列、工程号的唯一键
-            cell_key = f"{row}_{column}_{gc_note}"
-            current_time = time.time()
-            
-            # 获取上次处理时间
-            last_process_times = getattr(self, '_last_cell_process_times', {})
-            last_process_time = last_process_times.get(cell_key, 0)
-            
-            # 如果同一单元格在1秒内被处理过，则忽略
-            if current_time - last_process_time < 1.0:
-                logging.info(f"防抖：跳过重复处理单元格 [{row}, {column}], 工程号={gc_note}，间隔小于1秒")
+            if not gc_note:
                 return
                 
-            # 更新处理时间
-            if not hasattr(self, '_last_cell_process_times'):
-                self._last_cell_process_times = {}
-            self._last_cell_process_times[cell_key] = current_time
+            # 工程号级别的防抖
+            current_time = time.time()
+            last_process_times = getattr(self, '_last_gc_process_times', {})
+            last_process_time = last_process_times.get(gc_note, 0)
+            
+            # 如果同一工程号在1秒内被处理过，则忽略
+            if current_time - last_process_time < 1.5:
+                logging.info(f"防抖：跳过重复处理工程号 {gc_note}，间隔小于1秒")
+                return
+                
+            # 更新工程号的最后处理时间
+            if not hasattr(self, '_last_gc_process_times'):
+                self._last_gc_process_times = {}
+            self._last_gc_process_times[gc_note] = current_time
             
             # 只处理数据行的检验列变更
             if row < 2:  # 忽略表头行
@@ -1225,10 +1284,6 @@ class MainWindow(MainWindowUI):
             if column < 2:
                 return
                 
-            # 获取工程号
-            if not gc_note:
-                return
-            
             # 获取托盘号
             tray_id = self.tray_edit.text()
             
@@ -1341,9 +1396,9 @@ class MainWindow(MainWindowUI):
         last_save_time = getattr(self, '_last_save_time', 0)
         last_save_key = getattr(self, '_last_save_key', '')
         
-        # 如果是相同的数据且间隔小于0.5秒，则忽略此次保存
-        if last_save_key == save_key and current_time - last_save_time < 0.5:
-            logging.info(f"防抖机制：跳过保存相同数据 {save_key}，间隔小于0.5秒")
+        # 如果是相同的数据且间隔小于1秒，则忽略此次保存
+        if last_save_key == save_key and current_time - last_save_time < 1:
+            logging.info(f"防抖机制：跳过保存相同数据 {save_key}，间隔小于1秒")
             return
             
         # 更新最后保存的数据和时间
@@ -1666,6 +1721,12 @@ class MainWindow(MainWindowUI):
                         # 检查表格中是否已有线径数据
                         xj_item = self.process_table.item(row_idx, xj_col)
                         if not xj_item or not xj_item.text().strip():
+                            # 检查产品状态
+                            current_status = inspection_dao.get_product_status(self._current_order_code, gc_note, tray_id)
+                            if current_status in ['labeled', 'weighed']:
+                                logging.info(f"跳过加载线径数据：工程号 {gc_note} 已处于 {current_status} 状态")
+                                continue
+                                
                             # 如果表格中没有线径数据，尝试从数据库加载
                             xj_data = inspection_dao.get_inspection_data_by_config(
                                 self._current_order_code, gc_note, tray_id, position=config.get('position'), config_id=config.get('id')
@@ -1678,6 +1739,32 @@ class MainWindow(MainWindowUI):
                                 logging.info(f"从数据库加载线径数据: {xj_data.get('value')} 到工程号 {gc_note}")
                         break
                 
+                # 额外加载该工程号的强度(qd)数据
+                for i, config in enumerate(enabled_configs):
+                    if config.get('name') == 'qd':
+                        qd_col = 2 + i
+                        # 检查表格中是否已有强度数据
+                        qd_item = self.process_table.item(row_idx, qd_col)
+                        if not qd_item or not qd_item.text().strip():
+                            # 如果表格中没有强度数据，尝试从数据库加载
+                            qd_data = inspection_dao.get_inspection_data_by_config(
+                                self._current_order_code, gc_note, tray_id, position=config.get('position'), config_id=config.get('id')
+                            )
+                            if qd_data and qd_data.get('value'):
+                                # 设置强度数据到表格
+                                qd_item = QTableWidgetItem(str(qd_data.get('value')))
+                                qd_item.setTextAlignment(Qt.AlignCenter)
+                                self.process_table.setItem(row_idx, qd_col, qd_item)
+                                logging.info(f"从数据库加载强度数据: {qd_data.get('value')} 到工程号 {gc_note}")
+                            # 如果数据库中没有强度数据，但有工程号对应的强度值，则设置强度值
+                            elif hasattr(self, '_order_strength_data') and gc_note in self._order_strength_data:
+                                qd_value = self._order_strength_data.get(gc_note, "")
+                                qd_item = QTableWidgetItem(str(qd_value))
+                                qd_item.setTextAlignment(Qt.AlignCenter)
+                                self.process_table.setItem(row_idx, qd_col, qd_item)
+                                logging.info(f"从强度数据字典中加载强度数据: {qd_value} 到工程号 {gc_note}")
+                        break
+                
                 row_idx += 1
             
             # 设置表格为可编辑状态
@@ -1705,6 +1792,9 @@ class MainWindow(MainWindowUI):
             order_id: 工程号
             tray_id: 托盘号
             axios_num: 轴号，如果为None则使用数据库中的轴号
+            
+        Returns:
+            bool: 是否成功加载记录（True表示加载成功，False表示记录已存在或加载失败）
         """
         try:
             from dao.inspection_dao import InspectionDAO
@@ -1713,14 +1803,14 @@ class MainWindow(MainWindowUI):
             # 首先检查该工程号的包装记录是否已存在
             if inspection_dao.check_package_record_exists(order_id, gc_note, tray_id, package_id):
                 logging.warning(f"工程号 {gc_note} 托盘号 {tray_id} 的包装记录已存在，跳过添加")
-                return
+                return False
             
             # 获取该工程号的所有检验数据
             inspection_data = inspection_dao.get_inspection_data_by_order(order_id, gc_note, tray_id, package_id)
             
             if not inspection_data:
                 logging.warning(f"未找到工程号 {gc_note} 托盘号 {tray_id} 的检验数据")
-                return
+                return False
             
             # 使用传入的轴号，如果没有传入则使用数据库中的轴号
             if axios_num is not None:
@@ -1742,7 +1832,7 @@ class MainWindow(MainWindowUI):
             # 只要贴标字段有值，就可以写入包装记录
             if label_value is None or label_value == "":
                 logging.warning(f"工程号 {order_id} 托盘号 {tray_id} 的贴标字段为空，不添加到包装记录")
-                return
+                return False
                 
             # 获取当前时间作为完成时间
             finish_time = datetime.now()
@@ -1759,10 +1849,12 @@ class MainWindow(MainWindowUI):
                     self._loading_data_in_progress = False
             
             logging.info(f"已将工程号 {order_id} 托盘号 {tray_id} 的检验数据添加到包装记录并回显")
+            return True
                 
         except Exception as e:
             logging.error(f"加载已完成检验数据到包装记录失败: {str(e)}")
             QMessageBox.warning(self, "加载失败", f"加载已完成检验数据到包装记录失败: {str(e)}")
+            return False
 
     def show_pack_item(self, update_stats=True):
         """显示包装记录
@@ -2424,8 +2516,7 @@ class MainWindow(MainWindowUI):
             logging.info(f"开始处理稳定重量: {weight_kg}kg")
             # 这里不再写入D10=1，全部交由_process_stable_weight处理
             self._process_stable_weight(weight_kg)
-            # 调用打印方法
-            self._print_weight_label(weight_kg)
+
             # 设置已处理标记和上次处理的重量
             self._weight_processed = True
             self._last_processed_weight = weight_kg
@@ -2459,7 +2550,6 @@ class MainWindow(MainWindowUI):
         try:
             # 忽略接近0的重量值，这可能表示产品已被移除
             if weight_kg < 0.1:  # 小于100g的重量视为无效
-                logging.info(f"忽略接近零的重量值: {weight_kg}kg，可能表示产品已被移除")
                 return
                 
             # 获取数据行数
@@ -2626,6 +2716,11 @@ class MainWindow(MainWindowUI):
             net_weight_item = QTableWidgetItem(str(net_weight_kg))
             net_weight_item.setTextAlignment(Qt.AlignCenter)
             self.process_table.setItem(data_row, net_weight_col, net_weight_item)
+                        
+            # 更新产品状态为weighed
+            inspection_dao.update_product_status(self._current_order_code, gc_note, tray_id, 'weighed')
+            logging.info(f"工程号 {gc_note} 的称重已完成，状态更新为weighed")
+            
             # 获取轴号，优先使用当前行的轴号
             axios_num = self.get_current_row_axios_num(data_row)
             # 如果开启 api 模式，则调用接口添加到包装记录
@@ -2713,10 +2808,11 @@ class MainWindow(MainWindowUI):
                 info['zh'] = axios_num
                 info['mzl'] = weight_kg
                 info['printsl'] = 1
-                logging.info(f"使用的xpack: {xpack}, spack: {info['spack']}")
                 info['pono'] = info.get("pono") or order_info.get('ddmo')
                 info["dycz"] = info.get("cz")
-                info['qd'] = self._current_gc_qd
+                # info['qd'] = self._current_gc_qd
+                # 找到对应工程的强度，并从字典中移除
+                # info['qd'] = self._order_strength_data.pop(gc_note)
                 info['sc_gch'] = gc_note
                 order_others_info = inspection_dao.get_order_others_info(gc_note, self._current_order_code, tray_id)
                 if order_others_info:
@@ -2757,16 +2853,9 @@ class MainWindow(MainWindowUI):
                 
             # 保存贴标数据到数据库
             self.save_inspection_data(self._current_order_code, gc_note, tray_id, 11, 11, str(axios_num), "pass")
-            
-            # 更新产品状态为weighed
-            inspection_dao.update_product_status(self._current_order_code, gc_note, tray_id, 'weighed')
-            logging.info(f"工程号 {gc_note} 的称重已完成，状态更新为weighed")
-            
             # 重新连接信号
             self.process_table.cellChanged.connect(self.handle_inspection_cell_changed)
-            
-            logging.info(f"已将稳定的称重数据 {weight_kg}kg 写入行 {data_row}, 列 {weight_col}")
-            
+                      
             # 清除当前处理行的跟踪，因为称重完成后需要等待贴标
             self._current_processing_row = None
             
@@ -2781,18 +2870,6 @@ class MainWindow(MainWindowUI):
             # 释放处理锁
             self._processing_weight_lock = False
 
-    def _print_weight_label(self, weight_kg):
-        """
-        打印重量标签 注意：目前打印是写入数据库打印，不需要再次调用
-        Args:
-            weight_kg: 稳定的重量值（千克）
-        """
-        try:
-            logging.info(f"开始打印重量标签，重量：{weight_kg}kg")
-            # TODO: 实现打印逻辑
-            pass
-        except Exception as e:
-            logging.error(f"打印重量标签时发生错误: {str(e)}")
     
     @Slot(int, str)
     def handle_label_signal(self, signal, status):
@@ -2855,7 +2932,6 @@ class MainWindow(MainWindowUI):
                 if not gc_note:
                     logging.warning("工程号为空")
                     return
-                
                 # 获取托盘号
                 tray_id = self.tray_edit.text()
                 
@@ -2898,8 +2974,15 @@ class MainWindow(MainWindowUI):
                 logging.info(f"使用写入单元格的轴号: {axios_num_to_use}")
                 
                 # 调用加载到包装记录的方法，传入正确的轴号
-                self.load_finished_record_to_package_record(self._current_order_code, gc_note, tray_id, axios_num_to_use, package_id)
-                logging.info(f"贴标完成，已将工程号 {gc_note} 的记录加载到包装记录，轴号: {axios_num_to_use}")
+                record_exists = inspection_dao.check_package_record_exists(self._current_order_code, gc_note, tray_id, package_id)
+                if not record_exists:
+                    self.load_finished_record_to_package_record(self._current_order_code, gc_note, tray_id, axios_num_to_use, package_id)
+                    logging.info(f"贴标完成，已将工程号 {gc_note} 的记录加载到包装记录，轴号: {axios_num_to_use}")
+                else:
+                    logging.info(f"贴标完成，工程号 {gc_note} 的记录已存在于包装记录中，轴号: {axios_num_to_use}")
+                
+                # 将工程号添加到已处理集合中
+                self._processed_gc_notes.add(gc_note)
                 
                 # 删除当前处理的行
                 self.process_table.removeRow(data_row)
@@ -2907,7 +2990,7 @@ class MainWindow(MainWindowUI):
                 
                 # 清除当前处理行的跟踪
                 self._current_processing_row = None
-                
+                logging.info(f"已将_current_processing_row重置为空，当前 _current_processing_row 的值是 {self._current_processing_row}")
                 # 复原寄存器 12 为 0
                 modbus = ModbusUtils()
                 client = modbus.get_client()
@@ -4000,6 +4083,11 @@ class MainWindow(MainWindowUI):
                     self.init_seq[tray_id] = 1
                     logging.info(f"初始化托盘号 {tray_id} 的序号为 1")
             
+            # 清除已处理的工程号记录，避免切换托盘后出现误判
+            if hasattr(self, '_processed_gc_notes'):
+                self._processed_gc_notes.clear()
+                logging.info(f"已清除已处理工程号记录，切换到托盘号: {tray_id}")
+            
             # 加载检验数据
             self._safe_load_data()
             
@@ -4921,137 +5009,6 @@ class MainWindow(MainWindowUI):
             logging.error(f"查找下一个处理行时发生错误: {str(e)}")
             return None
 
-    def handle_inspection_cell_changed(self, row, column):
-        """处理检验表格单元格内容变更事件"""
-        # 创建唯一键，包含行、列、工程号
-        try:
-            # 获取工程号，用于创建更精确的唯一键
-            order_item = self.process_table.item(row, 1)
-            gc_note = order_item.text().strip() if order_item else ""
-            
-            # 创建包含行、列、工程号的唯一键
-            cell_key = f"{row}_{column}_{gc_note}"
-            current_time = time.time()
-            
-            # 获取上次处理时间
-            last_process_times = getattr(self, '_last_cell_process_times', {})
-            last_process_time = last_process_times.get(cell_key, 0)
-            
-            # 如果同一单元格在1秒内被处理过，则忽略
-            if current_time - last_process_time < 1.0:
-                logging.info(f"防抖：跳过重复处理单元格 [{row}, {column}], 工程号={gc_note}，间隔小于1秒")
-                return
-                
-            # 更新处理时间
-            if not hasattr(self, '_last_cell_process_times'):
-                self._last_cell_process_times = {}
-            self._last_cell_process_times[cell_key] = current_time
-            
-            # 只处理数据行的检验列变更
-            if row < 2:  # 忽略表头行
-                return
-                
-            # 忽略首尾两列（序号和工程号）
-            if column < 2:
-                return
-                
-            # 获取工程号
-            if not gc_note:
-                return
-            
-            # 获取托盘号
-            tray_id = self.tray_edit.text()
-            
-            # 获取启用的检验配置
-            enabled_configs = self.inspection_manager.get_enabled_configs()
-            
-            # 判断是否是检验列（非包装列）
-            packaging_start_col = 2 + len(enabled_configs)
-            
-            # 获取单元格内容
-            cell_item = self.process_table.item(row, column)
-            if not cell_item:
-                return
-                
-            value = cell_item.text().strip()
-            
-            # 默认设置为通过状态
-            status = 'pass'
-            
-            # 记录当前正在处理的数据类型，用于日志输出
-            data_type = "检验"
-            
-            if column >= 2 and column < packaging_start_col:
-                # 是检验列
-                config_index = column - 2
-                if config_index < len(enabled_configs):
-                    config = enabled_configs[config_index]
-                    data_type = config['display_name']
-                    
-                    # 显示临时状态消息
-                    self.statusBar().showMessage(f"正在保存检验数据: {data_type}={value}", 1000)
-                    
-                    # 验证数据有效性
-                    # 设置单元格颜色为浅绿色，表示已填写
-                    cell_item.setBackground(QBrush(QColor("#c8e6c9")))
-                    
-                    # 保持当前状态不变，由状态管理逻辑处理
-                    from dao.inspection_dao import InspectionDAO
-                    inspection_dao = InspectionDAO()
-                    status = inspection_dao.get_product_status(self._current_order_code, gc_note, tray_id)
-                    self.save_inspection_data(self._current_order_code, gc_note, tray_id, config['position'], config['id'], value, status)
-            
-            # 判断是否是包装列
-            elif column == packaging_start_col:
-                # 贴标列
-                data_type = "贴标"
-                self.statusBar().showMessage(f"正在保存贴标数据: {value}", 1000)
-                # 设置单元格颜色为通过
-                cell_item.setBackground(QBrush(QColor("#c8e6c9")))  # 浅绿色
-                # 保存贴标数据，position和config_id都是11
-                self.save_inspection_data(self._current_order_code, gc_note, tray_id, 11, 11, value, status)
-                
-            elif column == packaging_start_col + 1:
-                # 毛重列
-                data_type = "毛重"
-                self.statusBar().showMessage(f"正在保存称重数据: {value}", 1000)
-                # 设置单元格颜色为通过
-                cell_item.setBackground(QBrush(QColor("#c8e6c9")))  # 浅绿色
-                # 保存毛重数据，position和config_id都是12
-                self.save_inspection_data(self._current_order_code, gc_note, tray_id, 12, 12, value, status)
-            elif column == packaging_start_col + 2:
-                # 净重列
-                data_type = "净重"
-                self.statusBar().showMessage(f"正在保存净重数据: {value}", 1000)
-                # 设置单元格颜色为通过
-                cell_item.setBackground(QBrush(QColor("#c8e6c9")))  # 浅绿色
-                # 保存净重数据，position和config_id都是13
-                self.save_inspection_data(self._current_order_code, gc_note, tray_id, 13, 13, value, status)
-            
-            # 记录详细日志
-            logging.info(f"处理单元格变更: 行={row}, 列={column}, 类型={data_type}, 工程号={gc_note}, 值={value}, 状态={status}")
-            
-            # 检查是否完成检验并更新状态
-            self.check_inspection_completed(row)
-       
-        except Exception as e:
-            logging.error(f"处理检验单元格变更失败: {str(e)}")
-            self.statusBar().showMessage(f"处理检验数据失败: {str(e)[:50]}...", 3000)
-        finally:
-            # 延迟一段时间后再触发查询，避免频繁刷新UI
-            # 但要避免在加载过程中触发新的加载
-            if not self._loading_data_in_progress:
-                # 使用类变量保存定时器，避免创建多个定时器
-                if hasattr(self, '_load_data_timer') and self._load_data_timer is not None:
-                    self._load_data_timer.stop()
-                
-                self._load_data_timer = QTimer()
-                self._load_data_timer.setSingleShot(True)
-                self._load_data_timer.timeout.connect(self._safe_load_data)
-                self._load_data_timer.start(1000)
-    
-    
-    
     def check_inspection_completed(self, row):
         """检查行是否有至少一个检验项已完成，如果是则更新状态为inspected