From b6130bebccb7b707a85d0fff8effa5e4d8025558 Mon Sep 17 00:00:00 2001
From: "MATRIX\\29620" <2962004889@qq.com>
Date: Sat, 18 Jan 2025 14:57:32 +0800
Subject: [PATCH] no message

---
 .../__pycache__/command_25.cpython-311.pyc    | Bin 9728 -> 9221 bytes
 .../__pycache__/command_26_27.cpython-311.pyc | Bin 16845 -> 8504 bytes
 charging_pile_proxy/commands/command_1F_20.py | 201 ++++++++
 charging_pile_proxy/commands/command_23_24.py | 465 ++++++------------
 charging_pile_proxy/commands/command_25.py    |  53 +-
 charging_pile_proxy/commands/command_26_27.py | 450 +++++------------
 .../__pycache__/proxy_server.cpython-311.pyc  | Bin 17731 -> 18147 bytes
 charging_pile_proxy/core/proxy_server.py      |  52 +-
 玖行原始报文/1F.txt                           |  19 +
 玖行原始报文/20.txt                           |  21 +
 10 files changed, 561 insertions(+), 700 deletions(-)
 create mode 100644 charging_pile_proxy/commands/command_1F_20.py
 create mode 100644 玖行原始报文/1F.txt
 create mode 100644 玖行原始报文/20.txt

diff --git a/charging_pile_proxy/commands/__pycache__/command_25.cpython-311.pyc b/charging_pile_proxy/commands/__pycache__/command_25.cpython-311.pyc
index bf589cb806ac1eddfe397fe7edfd12c2213aa00e..1d17fb44e8121a2787ddd509caa2464ffe5dd74e 100644
GIT binary patch
delta 1604
zcmZvcYfM~46o6;;-hINpx=$_z?y?VsEFh`2wWcV$i%=ASP^8!pUYFJy>f`Pr+AKmU
zv<=llJjPASf}5I3eMK5*t&v88e~c#068S+$YWimv_7|WuR{i75F3?Tu<lgVhIcLt9
zGj~qzz>7mwnn|@<g~%AJIDh=U^_pfFW7+gY{I|0IGDawblqiS<oJE%;hafpcWFID0
z=7F_OLUcAwXNWFM(^;a+(sU`&<!QPsKz7?6f<jOZvSec){Ajbo8dmqKf_MxG89_;s
z3}I%FB~%BcNy^61c;@FM$5%UfFbZNpGse;=L7S9JQj*A|B(YmkM&)=$1G1xlWV;H4
z97ue+Pfjb-Z5st$P)@dzfK8F3&<nc;x2x=LMuMSF{+?VgHf+s$aW8s@X-2)cz|?br
zWKi)Bjg_&P_=PL0lb^*WM&qFyiO@{!o6zd;>9yGp;-N?)JmB&AR&RYB|M2o7p@9=8
zyIMQm4RrbAk=fYnNaxz@rK7R$XWV=|e2yS=h2n;rkDWW?=2s>^YI!7uNRN6VDn}?m
zKbokepeIeR6jFjyMqgJ)&vCwpKTP(6M(s=Z3z*a%D=#2Ue=flQik8--o}2a8?Nja7
zTr;j6lbA`9n6{JDwTu2Pfv2@YweAy+Hh`E-Q_)g*UZkxk(zFoO9>gWEUtg<MEUO+I
z7B1@Dtb#81Meph7$i)8&DSiO0tMvN9yV=f2d-&khCl|6yMtw`WU6HrKHKP?voFh^n
zE*kYNrToN|^Vn4!ZW(=kXL3)5Ok9+!O_e@ZNaR9k%_2D)v2nEv#=1pgUDQ~2$Cwr6
zTBjTY(S2O&O%t7Pt#gJg8A!>WkELX^sU<a8Ft#lk+oHy{ySe$GHB{g`&}itkoc1U@
z8E8I3<<&6rred#>`AI4DYGBEbBS~nd|1vy*OUlS8d+5FJ^hQaO#3N@{zddt+7oVjb
z`pt-E;>*~`cf|G_ylisga(Lfl%k>b~GA`c=jtvd1e0-feiL)bQp%>;&cI<<=sT5a$
z)ojC+aKOA9S3#56on1{+r#4;r0pjDIrnV+=FTjMkKzWGz?F4``vSBJ$4foA@nUfeq
z4z!j^?1CoC9$W_JEstAEh<Q2V&E)O33hjY*v6wDwhF>lFG)gk{|3O-gTq64_=&Vs4
zYgQMoqaEy>-mv~I-IGk-Mgv_G^%PAMM+gd7ktPz45-iKaE`LvVKr9AH-cz^-_UCQd
z+o-pb!b(9KGu3Xi&qWF;)bjRSuVJZm9i{OI4Dux^x_}|?pNHWV-w9Q=9N-nX3>(D2
z+srU$(?}vxz><8pZL?q*nHk|9Tb@%Il!y{R_Bs}l|BZ)#QG%iY6)306@=GziZEs}c
zq7!c0t(hWiZLyZ36aKYxxC6`%yXqt{43pPC1ztz7ZiB)4Ze|lv4jj5CgG-LHTmubC
yejHkF@?;{769st2nS<YeX6IfX>yhBBb@cz-NZL2kz16G^SK@V)Mi>0%Ecy>zFR!cs

delta 1845
zcmZuxeN0nV6u<ZN_4NZ<X!}~AAMl`l6+v5QabjQ!Rs2ARBW6Q!r1A>5Ah_ESSknrB
zX!hY$mKz7osNKfYO=oIw8!>J%aZ9#8OxmP>kS<${(JKGUIx)+VW!b&2l{wwbd%ttf
zx#xG@x#yny4sRZB)t=XA)PRhK<|BPSn6GHxgHSPZ68@<&@(cizK!k@t1gZc7!Y~X(
z{61$ckc9{#!sJXWKFSrVBeI+-&#G)r<+7?grz)~4ms6Eg)khRTNOQ;zQ6;KzVZLW9
zFU*_*Vt!aAAxlsbmJ`&5ISCb~!0G&Rgn4n14MCU@3r?|=B^FAOl_X(Gl5lfULFMVZ
z4qyjCveTzy2|#NjN}5mpQ<JC*EAg9F9zTQ{nO-!I<W`Jz0+Ej>4=P1tM{YI(N5H78
z6O2HIY4{i+tA*#rgY%!J&rCEmd(+YD_pTqm|IwlJ<k$0)S6^_vKYi`)cSq`l-Of?h
z+A6_0>U2q%oi~&D*r>}xO*PGXgz842##!U3cDkyaYXw(Ly~|VYcE1p`XR%5oHyL>i
z<b7O9U=om%g&`FHA`_AWs>wpcn;vrqaInLAG9hU{`1Vrz=qGn)ucc4aT}_{e&9lTl
zPupj{fWYU#0aNVWw}Sov{gi;{N=m)AN9+y`b?+MthSuSC3zy@wT6N98#tPyTFcTOD
zw{7Lo9Va_4R3xlbF@Bc4Vo6vU;(P<5M}co?N{Wz?%;rgoAY}0R_YU_7)xs;j5&XBN
zjYY-8X}h+!!AX__bYJ5j?rhCIvm3rL#CBXUT{SJ5q^Kd?(=c9t&yeUB@q+flB1%RA
z4MRIa$nFH$@y7-0;Y;{VLAzd+QU~|#_jgOXMKpcfSXd<|B?JN<ENmLHQucXLhjEa}
zXLOAjun0<nuJX2J=~R96jhJqFf5PHUTHLW<!m@6{J7--swKW=wl}|?!R!`FEnb<gI
zUNTh~-4%n=dlKf_q`7vYdG2{OA=;Kt?Yf|jxh`oEwz}k)t!`q|b2e&v!U3Z>Zf?s~
z;f9&WgtIkC%0z7Dwglgv<lEzX`!9S++`RjONPs-Comn~Ck(D>xS^49#tc-VbW+w^0
zE6I1o`7U{e17&vHtJ?_g;Y+%KqQgy%%`CXds=W%?P3<Z#Bm16_dlh)K-o~J!nKr!>
z!X`XsC^0sZ$_>-j5rp)aFYX=xrd~i^{H37^Zp0}=IoyQ*GFV{?F5&HPGj8Bra0?#d
z%i%Ws0dIw^_%dGw+wjkP32ettcn92$%ZwYiN)iy2;a+14T!}9mYsts%7*`a#i8+;b
zz=r~Uv0L;7eW;c??!gtNHCmcP;4x`(a)#^y+-HjGIGd(20~WyxXIhGWmDftqMao=B
zVJC&%6uJmFSVa2*brVQ&$R8LU2%=j2n#}_b;$yZ2P9pZ<cS^00!=IJf^$5y~GvFEQ
z$EniQT8;#u7x!_P^wlJeLjkWTdzp!{7&5$Cl!@#)(ytd8e4H~CM&N&bs&ZVew8^<J
zjLM0(9UBBA{;g~&R8TIyWzpk$L6fHlGl&tDgHTk_KOQHl$^Flp84z4hftJ$z0X|*6
zbDI)LJEj*gC713%O3{mk_V@coQwroiFyQO)qcXCJIw<rJaL7`Me&3)t;72JH`9%b?
z<?hAq3cET$958tUKVe_RD#srHr~<OzC7jDIn9x6xL6va<5O^eGbfyJznM~tbo+$Cz
zinq<L(oaYwr^P`uDMSOJe!SjpgTwfBd!3it%D|Eg_<wvP*%zK&-Nou)3(SCLa0Q;T
GSN{X#yX?IH

diff --git a/charging_pile_proxy/commands/__pycache__/command_26_27.cpython-311.pyc b/charging_pile_proxy/commands/__pycache__/command_26_27.cpython-311.pyc
index b0dc85afd91328e1fbe40b15097096622ebb1e03..5f109fe000c0f7027eb3f0f2fa4f488b9d3193de 100644
GIT binary patch
literal 8504
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
ZCPP;Wbfri;B-$b5?_~<nwNObW`ro!C><Rz?

literal 16845
zcmch8Yj6`+mT=2@+HTph{I-!TKL`lhAY1Yi8{!9G;|K2~7>LKX1vv3*+R_AEa)!x<
zK|>%o8<ThvlZXrn&Lm-+8fHcVB*RS2?&i-|)$QskRN609soF?JzgF4IRHgE3&$+Ef
zOE#Fz&iA$2r|&)Y+;h)8=RVK9zM<8oQ1EE#E}U#?qNxACNaRt31K<9ajH2G87>bdN
zQ2pXp)-NORr2ZuMCXL8P<^6IQl|<QO&qeZKSQ%l)$UjzmkVH`*!Jqgb^)8B0zDzNy
z_>_K?P0gsECzR}M;HmlmvV0WDNcC%M$!;Qd6cr9Inh!wMkKj*y`cofDnVdjL+ca)%
zB%kzaOHH6mv!$`e9?CZ*fjZrm#-!#)8TRX-oQ!Bx60oJ)bP0OUL)|kOI-VoZa;8o1
z&XQz~2IDoAn3Itm5N(tl$-rn=qd_`TS`dl)OfsK_8MNE%!=tt-)B25rlS3FZO&Y6=
z>o<<reqtLL8;r(BZIhFOCn438<WrJFpX$UoJ343|iWG_8h=soGfXJJajl%W>ZAtbr
z)h}m~04f+cKqaF9sKQp#uVz#LHH;cyGNS>Q!XyJsWl})eR9|ZQ_~_{17*k`Zu?|HF
zz{0R0$>HzYQUK79Wlm}ULgK?DK`ctmP{2yw7c7IsU^xJ&M#_-Lcc8{130pxgib>nZ
ziAl_C{JyoL>F9IAj?=?qCkF<{21m|J4o@B(IyK0iM9jqSh;3kk9Y1~MXqX!$M%dO3
z)YNaDIOEd{3=EGA+Xn`wvLsd69KohSIg@Dgvy``>$fdZL9{#w}UFqKfo*IgFE{M?Z
zM{3=ZhP6(n?9p0Mlv5UOc1HF*GN2}loiZkgk)KP7HCaaSJo2F?GayYK!#k<xq8vpE
zw!$9m@D%kN$%Q!?r9BzH;u9Mb5~X;Xx|$R(mkb7n1C(9TF&Xs_=LPa>m}F_)rjr0C
zV^ZR9awjywSUs84DG+>G0a%*RN-2**ZKsvfs%iDKW;)raVA9@JFzHSuqa$Ax`DQrP
z<g0gT!rx^4UQL}&VN#}3?dcJ{fW|bDFq7$&Ia8gfOcs_cEi-<Ikjgnt6ME3qbZR(v
zc4BU~#14_Nz&<(gT7Ssknj23wt%dTkr~dzymliAUAzI4|*IS-g??-4Y9k|NlYLTCq
z`yZ+`9h8?ZmiLfa`~cfC1ye9QOlJV^thl-q{y(jY9?C0>D^HtP-gKrtH`daenbH<3
z_AJ2BvEBwT=@^sAXyVec;$rJ!u@6)*@x!0^OlN^)+BGE0j*~2V70I&WB+HJIEIUrJ
zY(^?sHuG@Fa$=JG!|k6Nv;RMwcV3J)_Oh7fr}H6&j_F#GQt;4}!dS{bPSWXh50%jn
zE00l47dZ`#JiNf{4UZWsTW)b&`zT(eeH6#FkK(xYQ5@GkisRZx@gv$t5lAX&xe{#}
zV|93l&VI=FR{~ta<6qo7Ylt81W%09cku%ASD~uIS`~q~f89lC)VrR;lG)5=ACQXS`
zyCzMkGi^<pGAFhAHo%!4ua7l3l{<B7(yVu8yiGArT$RW3PSEuRr+!UN8=YBe(wLk%
zYtn3T=7K~OYe-b-%zF%~DrY`WZC-=d7H7d@P?^Clu#R2%I1A%-w`L8io$J=5se#fY
z>#|s>&V*jE8YgEFtB-5r7H83Fba6CRC{Y(HCl+!V|A+Of1x~AOFr6i9a~h_Yy2tC;
zugjQvX9~auCk?RCsRh{NOar(TB#^AwC3Q*YLqOZ?)B$X9W&qsg)C1h^%mVnNGY4R+
zGZ$c+GY??9Gaq1wvjE@@DB-bM1JLetu6rGJe2-^OXAw|7mK}iZv9!$WnpeCJ+vzgO
zj{C{*Q%<qZOqa&(mNFx0OsCxx3ByjUbZx6WgiqHG-zgo2eb;p9i>0{x5<@S@UZ76P
z4^uD5OuHSIK)w`X_<3;SSAlnCYAl_B`LlsH7X9bWEzkb$!Oi#lm#+9<`|RsG*HfaT
zO%sFc;HVMY34={W|ILemE4P;4dKt2cgn<k12i`azqh@V(2Rqhe6ie{Wyb8qrPu}#O
z^8{RP^o@_%qNG7=4J>Ydg9yGwu=^QDC48dX{hk{E_g(+p%U^pg1wQ%J^0k})dH16K
z)pz|jUJ(m!GWI!ee=Q0YpAy8)Y!J8LK_m%sY5=(X4dR;9CpTM}?`2i+t%0xcds)->
zNzGkB1rivMKnZS>;o<LP6yQ69xC;w12(S$WantNTo2NWNi=q;i@4Oy(XTHgSJH^1Y
z5B-<_&}4LA<pXd2KKSOXfcyM|-~1d<$oIj`MgM14mT$f1zk5X_L~NXWNOp9kEzd3l
zTz}~52y+vo%b(uyzw-*9u*%DKUS7U)J}`ef@XpI$-}%+D`)A=|M27xL*S`Mjm%;b0
z0v2`UKle{l%BQ;e!nyr-&w`#sQc=_>+t&kE-(4j^ngbeC@ciW_qfh?))2G7H#Ii+F
z9cUgg+krjpO<;xf1cf@g`Yu6<s(ST?-}U>z8-Ikh08$X`5tRS(OMxqkVU&O7H~tF?
zaVqfNd<$e36QY&C>|ya2uEjX|e>NZZ<UMReZ@WQoHSquqGrnYWo=w^ZM<;wVYa1G8
z8F2bAw$r}ssIv%gHg;glF?!s_`qYj|h+sw%u%DT*`84C~$$_D9#^$4k27$rx!I8nS
zA)8PBli@L6CNO9115s{Ro-e~T#w4J!6X*s<#~ovKUuGO-7?~{6PL2=x)R>L|dT4yi
z&W?`^jG`dgNR0GwlfsuGW+C!sgu}z5=nEqPX`}Ly?5UIX@reP}HaIyx=D_`8bWjmT
z2LJU>AKZFBVwt!;Ys&V?M{Hv(8sDcL89#{*H=p{2L3RuSn&ZP`r0@CEr);N3hEJUF
zDJR%rsHtkw&N_zR>lm9D9D3fTV!#|w6%`8!!xJpFVxJr``Sd4k_JOGS2kf@fc3(E)
zB9+EEi0Dj2$Eq$Oa|mt37Z@YX5{aWV7paqXoF1}G*oVi*d`cV3j<Y^F2xKZ_aZdFq
zaPahL!_8^n_!+xx(wBld4TlwHY=f*%ISSS}<&!gmXMBoN;||uR0_8jGP`yd0<`~0P
zAvf)igJo@FcCihzn*qmeL10Euji3gB1%VZSFJG)&)O@j$*;-7`jcY%W)H-BQkDviT
zBZ4LbTM;xPXhE<IfG>ANixF$bZby<Qkwj*jEQ4=k7J9^&#V+bAhL$;L11IjOfe~<L
zPfEH7>2OmOQm5-0#JD(|+y}$>St^t^mXw_5PuI^_e{tsGnYo$^FS=fIXSoL#WbUEs
z`3ttC5(`&iS+sjvZ@qA@{I6S<>i2Q=`@YoW&Zcw5lmF+muxEh#5yS7X343gSfS1>u
z5_G3H-6?Nw;f($7DoU&8^sS%d38qF*Id9r7n6^V4UY>3f=r)dS3#lkWi95qx<IbAj
z?dpYSLDAfCw|>qxU+CKH%{0sn&bGL%eC7sMhj&Y(r^M6hDf{@RJYDJ9F=Lri%$;zb
z@D>(xc|Q_gw=Ei6EQ<y`9ns*upG1S)!TxC2)%Df7B3CbnysmV<Wg%<9zSw)OirasH
zZ#%$Q4+vWh@`Z<l!b99sPYZ?5xO%*F{@gyEhAbfRdeeeoarz$1*LQKIE}?w){qlWF
z<@>n(hxzh;p}hZo`QTFdAb0!}Up_394|8-0X5Y`##Uy)f;atmt!K3F*Te-rmLQeDj
zoc5)h_ItbdoE{;k=YGzCrJMsGET3~k$T{NL70V3b<`>Uv-ONJAqQNu$#gF;zd%5bp
zLghX_Z@-YYpF40+$UEffijy{P-CXZNm8XQ?w3S=8Rmg3=pWD8ai^b*k2)RA?a}O-#
zlHziY2)RdGow3Z1sU7afvwY#R2|CKmotbtYTinmDujg{>1%1PP{q`mO_Iqkx-zn%j
z@9Xz0>GyDZpW^jT3;L&B?XgONf=yKm$2=`xRP$SVxT+puV=qUq|FU$GS7%x%5p<Oc
zc3x+RMArI#qg9us{fz>^(ZwMhr7egVazn*Ji^uRq2H&`wtJp0((aq6iUm7=hbsH9B
zf^O5oL0(rKiLCX7a!RnA5-7(YEeEu?zT$fCV!21*Irc>hcjPGFeUxiCDl{D9%byj>
zpXCOABtUavPV(g^!)--uYLK(cbiHa(vB-cn4BX*<zN??x+Aq`{;Y*JSrAN7A&kCgj
z+;JOUYJ=LvEC)KwH_ROq@+uM<1GYUO$0RnYXoFs7bZdpe%~BIW*@m+D-i2}~{n))0
zXjy#wL9X_oU_QjJdrDaM6!-Kq!n(t*-nc@cGmi@SmC%!={iS3*sKlENJ?O$uT|f11
z+Pp9gn%Kv;^l@AIgiU)m-G(pAE4^723#~%d=EW>Nt2Po@>kC?6uLrHK*K@iO(0WFZ
zJA>Di&S*gcFwhu;bz7t&Laho*=BpMI3(R86Jp;FIKi|5av+Nf(AK(iP3IzwbLr)0>
zPrJHf@<SFJ)wc2Uc7fi`(c8bIGdO+C+_C$H%}a*OyumCO%z%KGr!4|);b;pX+3arQ
z^qb-3=`8}ig`>9+wADSr>8<ecbge+wa&#?0w{TBv<@7D^^7J-=-p0|}2!7+-3!Hu<
zygY3ZXcI@92zr;>dcUk`sjSJ<$d~O9%64%2UGVaBr$BddbSELQEaY)|3%opS6=*9*
zTM4=zC8!r)o^BB6299okl$olzvYD!xDxNk9w2`BYgnAoiYKH2s&_FY1YU1>e)XdW@
z0^P#VErh<EGXZhC`0{jzKzDF-2T5urtZ+V%P6;Hb(w)rdE5(<ms|31=qpL{DCbyc?
zZxUagt`O)7j;<gny{LnhrLq>!2w&DMly!6ZUU+%BPoVoax{namxIw2YjnjpBw=R`!
z_3Y-$b_r#mye@codbdFD=IGttbYqB;Y1?F9>aw|<C%LL^2y>p~b*+M~mD9Bn=6jIK
zwxzOdo@u_US15zx_rS~3dj)zgNAD#>-AL5DRMzY{!k2XkWl#=C+Rf8F0^P&WJt0L-
zR+?9rKi6`<uyU!ek}up0eK8~l>{q(Nxx*nPgrGTR6uaq=8p9eYV<Tuel#G!SDx+Yo
zK9q`Kn#x!=cksT!x@52}9_9_(1;h4`7E{uwjKaCjP&$U8mmsSQ4C|?koSDf`CWf=9
zj3>AaO`&Xz<WL#q-1@puE=Kag1?FR<AWT+>k#$(&;gA8tMWQ6d7&c-Viu=Z<C1aDP
znKyO{#?DX)rj$|{Mz<kUhT(Fmxa@vW-BMBA;uK%hCKR=K*VlPV*55B_UMgw!9OFy6
zg_3SB5EVBp6*qVa`QjZy@s3ahW~L-SoA%w`&6F-bM9Gu$V&F?U^I|Vo(EPi0kL=T(
zw{}7hUP*f;$?cys2o+mB9ehQrP|?a2w8I;1xL%mZtdZY$@PyP*1bioru(W!qweX0H
z`g8H&68QYPEahmK{NGbswMUEO|F=j9ks(~0M;=`GWBl7v*ls5tbjQ1+r{QSV9X+&;
zFu*U9a3C(DfKqy#9wmlj?`Y}qt{IYNRqlxg-4Ex^tT+Id9@{6>MzOksCxJ@oRIFZS
zsRQyk@Mnk*BX=q#2hoZta1Q_mT^8hlaP;mCgi-queDpv7@KFcg2f+EGDEAc_`=80C
zbSA|g<*wlO5c@u)t}44BB0tnp5zp<1m6XT@t}v*lRd9JA;p#yLbxb|2cB-7}DLCVq
zR$bIQw8g37<$~jZ;+WJ-!i}SZ)KuWQszWorm8|NZmX<=tX)58s0v!0-RowizKMOz3
zgdD3lM7K<9>>DEVa2W!fPUK<I>=ltPSSjI-*J_f3`!ac2^CD;*+?OOIabKo8{sP>h
zuEXWocLT1O8f&NjkH7U_Ui82Hj{o|l$984L?Zd&RNt~bHm=k?-;H-Rb;iYI%VfUxh
z?E}uucrRUyIO6?8(O$pgzdf7a9%WHMES?Weshiu#!{#B%h+sVe9Kcv~EcZEZYY&`O
zshG(7%3|QsO>ph`@7xA;_%FQMBs#_j-v9G+{+oY{_{s<>c;!$2+aCZ*1&qad5*KDv
zoewL?fBtrG_LogYQ;shgy%&Ql3qA@J_*B4i;8P7wOu(1Lp(N~q85@6r-33vf0^Kz1
z)0pxMg2M><5gb8q6hSM3od~)C_>{yy!tO&v8-o1^4gfGE6MqVO2ob0ppYjCwrfuv&
zM4Tjup;I>S3(1bNgAkp>5isgy5Pb^eCv9Uk7Q6`qHP%xx|C;E)V{MZY<71PyDYMkE
z@HjdC6^r{j%p~Al&}{_gLYCpR?%8hF4lkW?x#vR9TsG`^1-h8*O+-xAd~tLo8=*4r
z^ag?6z|k8bm@L?83v>}j7s2uym~Nfj>gs@CX5nn*Ynx{`<9<<hx%)!*Rn>f|yUSa?
z;d<wS{o0<z1Gf&}lmAsMB8EPG&Qo@G(>Kbb{GGDDQ3$`GlC--p3@{|Z6iS;BW!14z
z$>-GzdG*nSF|53_daTUVocTic!A~p;_759BZshZ8h5TBct`q1wj;@PR&Ba6qTy_rV
zBD-L&dah=!X7(^HDGLdhk$H95a~ZFt%qVA+ky^*J<;Oin8&9_jbUR14lXaxoU3;VP
zy~b->ufs+Gb{uA&t`_KOj;<!jweMTpj%!WVVNqTyzER=)nR#>BuQks$gB`x}r^5mX
z96>P<UM2PY%g`4ke?IZo6I?+byga=}p!aa}o|P*gC1l4H5O(61cIkIzQ~#Eo(wQdz
zx8m~7Wce4#N(jeY@k1{ZS@}#rTfvnN97+Ld<&(JnfNO6_XLIb)bqtKQ(Y4OX6$m4T
zD|k}cXqZtrlNcoqLE;1RfC@0`IE)4`$#Iwzz(_8TKrR|E+7&cuahUY0EAOi6$UG9g
zHb+r#u(oAd9w#lHu8@bxkgfs}XQYSBBeH4vi*nQeLqd{yMDO@Hu#Jw_{_8I<&;0xm
z2RQ%hW3a&7Z~QYKh@-PuTD0&!2j1w79(9Ee%!t!`rvsN_f!W{tU5nzZWMuJN%ux!!
z2q$VQ2Wp&@$no9fKNyKS*nusrGBUf7lO`i^_fE;-7BGvh-8d5QM8+s__ih4`gT%8R
z)l=BBADIr+>~WwGN9lG5`4q!raC4Xp-LX+yA&%NONc&QWla?7kkGMEQ!v=s1(c<V_
z0vB$F;6Cyre7;rEp?OX6?|}Ver8q99WhUpt{oDHm+m;HpdF*^ahfvVr>i#OdfJ-k8
zJ9q1OU4x)&;B*b%+;uY!ba`Z5><J~wGkz>{r!I5}#yZ$kK}3XJ18hH^6b!8)c?|iL
zv4X2?6^v~mr3ASPe3B=GT_>eT7#B+_xyp9I*a4fVC|5x5mK~CDhn^F<o{vi)MSmk#
zYQet-AVfeKm6bPRjSOe7^Giw=!5W)BZ)V<1ZR7`|*mofq&hl|M!xi>R6|K$GZ(36U
z{<%4&tycaQRe76P{ui?n!f|67E+=q&`L+`PUe?Cz$c%zfGOBqcj$3ZPuYBMduNtrS
z!o}NUSc$@D7W+>FxYC{C&_kZ^5h^+A6c6?sIH^DQ{ki4aH{bx1#QgIM%eVg&i7kI{
zCmh2r5SahiKfkzq^BVMY|7&xE9?m#}zql2+`cEb$S&WhO7K`1HH6bVf@ONB+2j+jh
z{O<c=xyFs=(|B0?%=a?WhccfW4uVW_v1#L>i%)~+W&@*x6O*V5SapyV&GtZKsz};q
z@dPRUWGV~V=VS*E!s0<i=?cB+1>`jX45g~FQbH5}mj-+ny1dKI3(mPNZo_Vm2|)Da
z)4PTAZcfw9qTs9B2NzjV`^+mIX&n_>2&|)7#X89n>jWf+vkqJZiifVa+&p(Kf)K|S
z2_ks@H8^^XARe6mH5}bSEO6(VNs(xk5@70x8ALn>MuV_+NMRiaegfb_(I7qrIib{$
zW4jd==>@{6l0=KFI2SBNqqG98Xp|yvIyi3e4J9klA^^Z5bi^VZT<MdG2LVK1KD|{)
zZ{;+tD=nf1wxq}GhJe%}jEYgus~%|;4Ok@^tdg>dRZ=BZ0bPR51LT047$NY>o58bh
ziD<F~c<|XxR6q77|MeTNe^`F?ytH?PjfY%5buZt!6}WJnBnRG|4V=9JSxu_d3>E7`
zQj-xmRxuen1;xjAnLU7+DqUfq6^F4Vv=DAHq87@H^c=8LK}f4cI{^SY>3)!%q9a=y
zloGMie9|NBqX7FT!9J>0?4y?2M{-$#*k}2pSNxZLD_&KI^qT111yhnl)srAiLd%Z~
zMdUp8G^EF?v=1;-#fd6SIP|VXed5t>RG$WztWbvlK!=)$4tH}Kdpu15qA#D`E2Q^w
zn%<Rd9ZzyeTfYZ^Hz~NT2J-`4@`4!xAj}Z})r<yUGJ}`X;9@dBErZw6(iyyJmcig9
zvrGmrnPoG0$t;(_>t*>2UMwqQ;IbHFV2S`1Ge&?VOew%Jrkq*NJi%;WHZmq=6H~!d
zGF8lGX3ISNzU+|}G=l}J!GblbSkNN1pya*?nLR|S-Mx)hRbH75yz^_)705CRI+6dA
znc(ct0$0uj-<l8N2;jh7L-@|hovX`t=aA^tSHz1GL0ln=SxMU0pS>z(WuL$VoEw)(
zLf}_t1HXGE%og2zgl#zOw=V}~KM%9L`;y<|VRMk85Ob4m?Z5uU*Pq{r6nx|B+pkue
zp9<n2PRefE-z&N>V8X@gGq^4l6WaGm6IhgoRKIQio&mEtOpX&U88QGHM&T$fqS|{z
z6uU8oIuNEJ>~KOBr4;3ZOJM$se+-_x#Nu@miS~l;y(|uEG3{YqQ4wM_FJ1Ziv)4s7
z5B_vM_|aUDC;}}Y76Dh^q!gfTA|+fw66qx|Ov8}@5(1tN#Rl>D>)<4j@)z5Jc(D%X
ze)ls%2MhWKpMU<~=I1a)!a5$flU+apTI55ll#n8oQp_oi^7FU9_T0e<lr%|FcDMzQ
z<|Z-t10v~zKfM!p^?m;@7yP7E5LO8(V(m<H5S1N7MFnwP6hsdriyM)k1%VYoEdtz9
z1abTc;(d@HUi*+t0OGZ(@FL3kOl-~$k6dtvhg>D{rHJ2^E2+J}aLTxH42!>u(}IIo
zJpdTQ6h%2HURvvVF(il3SG1Ocvn(Y9VU?v#<I+tbHAXZfVhkl?1biTnQWi?Z2u*3z
zIo+m^79(jSQWZ+a2%MfnN=YaKBl>V86C+s=nMn&}V>k!Hsi9m9=ZWEb3>S#uLJY5i
zFdX}a3>YaQkxijuj2Od_5{#6FBV`yVhqERxtP^#4UR}9YS47|judWJ?=1CL-p{+<t
zMSv?Mw2jggTz>Jwi*qNqCw6*r07PFteV35Fi_`2P19+c_#(!<Ze-a%S@TCmkg)s;G
zJLG_m9vJwsW03s&=)eGr{af4vj$-J?2yns6;u?#^d7Q<WhegwUND<cJsu+hq76A@e
zlb-@O8~ufnl9a`;iHQJ>BS{H98VMXznh_HPjI2NjJDw<LNLKd122BEUG|D!>NMKe9
z!AM}9O4$cA5~wRtb^>N~DAoq+fT|iD93C4O`14+9c-Ge1h8m06Qe9tHS6f$IZK*TY
zS?bNztroMny3t&1ZZx;m)K>2>SGU)gTg~uTsx1wcdiYga8UZ$7W=kFX)skNw2_s>`
zV`;FOEmjNg{b5ga-O7B{_S#l!y|vZaZtbvGtyW8It+}=VWT}RdYAqH^eY6hNnvQ6=
zwz{otM_qee1JtTc{8}5Wjb_VEE7TYtYn0Ynv(sF?6VlAp)oqXxkw5Y!<dDl^ZZMl`
zcKWPDqfpgEjhZ2MlxuAbL?Rk(Z}sUC>50qOfm_>@M|jnn9A=<c)hz>ej{|SI1HZiz
zb(o7z{{J}pk|~GyyG2(>2QUyF;i<<5Cx?gH$Hz_#pY$oZ`gZOijh>yuR-+=m5SAUr
zi24LOK8hC?X>!l4#zI^qk(gC<m=JHv1ad!w0A1iLc08XZ;<#pUi%0zEqTBp!jOq~J
zGVFUzv)GZhu{R(JZIznDv&xWMCX;z7?OF2kQfX(&&r7ABB|k4^;No8xKxJ8H)dH0{
zw_(1L+tSZbM|kRpKplZVNOe#t!;bUt&o^S)-{MIoQYZ!Onp%?QbMpMJw0W*0zc_aB
z*x8*hLTBZ_+49dVp(HB#i1HhGQkDuF*IBBwJuqI2NnXvi1bk-xeSO1{zQMDO*Y6bc
zJI{85)S65j1$N86$}_yHeM`$d(ZJ_53VDq#tv9#Sy-moianWALnYnE#6Yes6F~Vma
z5i*asG+vF?rR35!^O`M!W(%j;LJ+P~mq#v){9^3l7_Tu18Uq)3ztUv8)EBi}PA9MF
T5;R?0<PFtRiUOz}vC4k~<T$7x

diff --git a/charging_pile_proxy/commands/command_1F_20.py b/charging_pile_proxy/commands/command_1F_20.py
new file mode 100644
index 0000000..17da1b3
--- /dev/null
+++ b/charging_pile_proxy/commands/command_1F_20.py
@@ -0,0 +1,201 @@
+import struct
+import logging
+from datetime import datetime
+
+
+class Command1F20:
+    def __init__(self):
+        self.command_1f = 0x1F  # 启动充电命令
+        self.command_20 = 0x20  # 启动充电回复
+
+    def build_1f_command(self, pile_id, card_no="18771978016"):
+        """构建1FH启动充电命令"""
+        try:
+            print("\n构建1FH启动充电命令...")
+
+            frame = bytearray()
+            frame.extend(b'JX')  # 帧起始标志
+            frame.append(self.command_1f)  # 命令码1FH
+            frame.extend(pile_id)  # 桩号
+            frame.append(0x01)  # 数据加密方式(不加密)
+
+            # 构建数据域
+            data = bytearray()
+
+            # 添加时间标识
+            now = datetime.now()
+            data.extend(bytes([
+                now.year - 2000,
+                now.month,
+                now.day,
+                now.hour,
+                now.minute,
+                now.second
+            ]))
+
+            # 添加枪号
+            data.append(0x01)
+
+            # 添加卡号(32字节)
+            data.extend(card_no.encode().ljust(32, b'\x00'))
+
+            # 添加用户ID(32字节)
+            user_id = "84043"
+            data.extend(user_id.encode().ljust(32, b'\x00'))
+
+            # 添加组织机构代码(9字节)
+            data.extend(b'\x16'.ljust(9, b'\x00'))
+
+            # 添加控制方式(1字节) - 定金额充
+            data.append(0x03)
+
+            # 添加控制参数(4字节) - 1000元
+            data.extend(struct.pack("<I", 1000))
+
+            # 添加充电模式(1字节) - 正常充电
+            data.append(0x01)
+
+            # 添加启动方式(1字节) - 立即启动
+            data.append(0x01)
+
+            # 添加定时启动时间(6字节)
+            data.extend(bytes([0x19, 0x01, 0x09, 0x0B, 0x24, 0x2F]))
+
+            # 添加用户操作码(6字节)
+            data.extend(b'ws8quu')
+
+            # 添加计费模型选择(1字节) - 本地计费模型
+            data.append(0x01)
+
+            # 计算数据长度
+            frame.extend(struct.pack("<H", len(data)))
+
+            # 添加数据域
+            frame.extend(data)
+
+            # 计算校验码
+            check = 0
+            for b in frame[2:]:
+                check ^= b
+            frame.append(check)
+
+            command = bytes(frame)
+            print(f"启动充电命令数据: {command.hex().upper()}")
+            return command
+
+        except Exception as e:
+            logging.error(f"构建1FH启动充电命令失败: {str(e)}")
+            print(f"构建命令失败: {str(e)}")
+            return None
+
+    def parse_20h(self, data):
+        """解析20H启动充电回复"""
+        try:
+            print("\n开始解析20H启动充电回复...")
+            print(f"接收数据: {data.hex().upper()}")
+
+            # 基础验证
+            if len(data) < 14 or data[0:2] != b'JX' or data[2] != self.command_20:
+                logging.warning("20H命令帧格式不正确")
+                return None
+
+            # 解析数据
+            pile_id = data[3:11]  # 桩号
+            encrypt_mode = data[11]  # 加密方式
+            data_len = struct.unpack("<H", data[12:14])[0]  # 数据长度
+            data_field = data[14:14 + data_len]  # 数据域
+
+            def parse_time(time_bytes):
+                """解析时间字节"""
+                try:
+                    year = time_bytes[0] + 2000
+                    month = time_bytes[1]
+                    day = time_bytes[2]
+                    hour = time_bytes[3]
+                    minute = time_bytes[4]
+                    second = time_bytes[5]
+                    return f"{year:04d}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d}"
+                except Exception as e:
+                    print(f"时间解析错误: {e}")
+                    return "Invalid time"
+
+            # 解析数据域
+            parsed_data = {
+                "pile_id": pile_id.hex().upper(),
+                "timestamp": parse_time(data_field[0:6]),
+                "gun_no": data_field[6],
+                "card_no": data_field[7:39].decode('ascii').rstrip('\x00'),
+                "user_id": data_field[39:71].decode('ascii').rstrip('\x00'),
+                "execution_result": data_field[-2],  # 1-成功，2-失败
+                "fail_reason": data_field[-1] if data_field[-2] == 2 else 0
+            }
+
+            print("\n解析结果:")
+            print(f"桩号: {parsed_data['pile_id']}")
+            print(f"时间标识: {parsed_data['timestamp']}")
+            print(f"枪号: {parsed_data['gun_no']}")
+            print(f"卡号: {parsed_data['card_no']}")
+            print(f"用户ID: {parsed_data['user_id']}")
+            print(f"执行结果: {'成功' if parsed_data['execution_result'] == 1 else '失败'}")
+            if parsed_data['execution_result'] == 2:
+                print(f"失败原因代码: {parsed_data['fail_reason']}")
+
+            return parsed_data
+
+        except Exception as e:
+            logging.error(f"解析20H启动充电回复失败: {str(e)}")
+            print(f"解析失败: {str(e)}")
+            return None
+
+    def process_and_respond(self, pile_id, sock):
+        """发送启动充电命令"""
+        try:
+            # 构建并发送1FH命令
+            command = self.build_1f_command(pile_id)
+            if not command:
+                return False
+
+            if sock and hasattr(sock, 'send'):
+                sock.send(command)
+                print("启动充电命令发送成功")
+
+            return True
+
+        except Exception as e:
+            logging.error(f"处理启动充电命令失败: {str(e)}")
+            print(f"处理失败: {str(e)}")
+            return False
+
+
+def test_start_charge():
+    """测试启动充电命令"""
+    print("开始测试启动充电命令处理...")
+
+    # 创建处理器
+    handler = Command1F20()
+
+    # 测试桩号
+    pile_id = bytes.fromhex("0317665611360637")
+
+    # 创建模拟socket
+    class MockSocket:
+        def send(self, data):
+            print(f"\n模拟发送数据:")
+            print(f"1FH数据: {data.hex().upper()}")
+
+    mock_sock = MockSocket()
+
+    # 测试1FH命令发送
+    print("\n测试发送启动充电命令:")
+    result = handler.process_and_respond(pile_id, mock_sock)
+    print(f"命令发送结果: {'成功' if result else '失败'}")
+
+    # 测试20H回复解析
+    print("\n测试解析启动充电回复:")
+    test_reply = bytes.fromhex(
+        "4A5820031766561136063701680019010 90B242D013138373731393738303136313535353636313000000000000000000000000000003834303433000000000000000000000000000000000000000000000000000000160000000000000000000003F4010000040119010 90B242F7773387175750101 00D7")
+    handler.parse_20h(test_reply)
+
+
+if __name__ == "__main__":
+    test_start_charge()
\ No newline at end of file
diff --git a/charging_pile_proxy/commands/command_23_24.py b/charging_pile_proxy/commands/command_23_24.py
index b621c8a..e144321 100644
--- a/charging_pile_proxy/commands/command_23_24.py
+++ b/charging_pile_proxy/commands/command_23_24.py
@@ -1,381 +1,210 @@
 import struct
 import logging
-import binascii
 from datetime import datetime
 
-# 配置日志
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
 
 class Command2324:
     def __init__(self):
-        self.command_23 = 0x23  # 最新充电订单命令
-        self.command_24 = 0x24  # 平台回复最新充电订单命令
+        self.command_23 = 0x23  # 充电订单命令
+        self.command_24 = 0x24  # 充电订单回复
 
-    def parse_23h_latest_charging_order(self, data):
-        """
-        解析23H最新充电订单命令
-
-        :param data: 完整的23H命令报文
-        :return: 解析后的字典或None
-        """
+    def parse_23h(self, data):
+        """解析23H充电订单命令"""
         try:
-            # 验证基本帧格式
+            print("\n开始解析23H充电订单命令...")
+            print(f"接收数据: {data.hex().upper()}")
+
+            # 基础校验
             if len(data) < 14 or data[0:2] != b'JX' or data[2] != self.command_23:
-                logging.warning(f"23H命令帧格式不正确，原始报文: {binascii.hexlify(data)}")
+                logging.warning("23H命令帧格式不正确")
                 return None
 
-            # 打印完整的原始报文以便调试
-            print(f"完整原始报文: {binascii.hexlify(data)}")
+            # 基础信息解析
+            pile_id = data[3:11]  # 桩号
+            encrypt_mode = data[11]  # 加密方式
+            data_len = struct.unpack("<H", data[12:14])[0]  # 数据长度
+            data_field = data[14:14 + data_len]  # 数据域
 
-            # 提取桩号
-            pile_id_bytes = data[3:11]
+            # 打印完整的数据字段用于调试
+            print("\nData field hex:")
+            print(' '.join([f'{b:02X}' for b in data_field]))
 
-            # 提取时间标识
-            time_bytes = data[14:20]
-            year = time_bytes[0] + 2000
-            month, day, hour, minute, second = time_bytes[1:6]
-            timestamp = f"{year:04d}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d}"
+            def parse_time(time_bytes):
+                """解析时间字节"""
+                try:
+                    year = time_bytes[0] + 2000  # 25 + 2000 = 2025
+                    month = time_bytes[1]  # 1
+                    day = time_bytes[2]  # 9
+                    hour = time_bytes[3]  # 12
+                    minute = time_bytes[4]  # 21/22
+                    second = time_bytes[5]  # 44/41
 
-            current_index = 20
+                    print(f"Time bytes: {' '.join([f'{b:02X}' for b in time_bytes])}")
+                    return f"{year:04d}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d}"
+                except Exception as e:
+                    print(f"时间解析错误: {e}")
+                    return "Invalid time"
 
-            # 解析记录索引号
-            record_index = struct.unpack("<I", data[current_index:current_index + 4])[0]
-            current_index += 4
+            # 解析每个字段
+            parsed_data = {
+                # 基础信息
+                "pile_id": pile_id.hex().upper(),
+                "timestamp": parse_time(data_field[0:6]),
+                "gun_no": data_field[6],
+                "order_index": struct.unpack("<I", data_field[7:11])[0],  # 订单索引号
 
-            # 解析充电订单号
-            charging_order_number = data[current_index:current_index + 32].decode('ascii').rstrip('\x00')
-            current_index += 32
+                # 订单信息
+                "order_no": data_field[11:43].decode('ascii', errors='ignore').rstrip('\x00'),
+                "user_id": data_field[43:75].decode('ascii', errors='ignore').rstrip('\x00'),
+                "user_type": struct.unpack("<H", data_field[75:77])[0],
 
-            # 解析用户ID
-            user_id = data[current_index:current_index + 32].decode('ascii').rstrip('\x00')
-            current_index += 32
+                # 费用信息
+                "amount": struct.unpack("<I", data_field[77:81])[0] * 0.01,
+                "vin": data_field[81:98].hex().upper(),
 
-            # 解析用户类型
-            user_type = struct.unpack("<H", data[current_index:current_index + 2])[0]
-            current_index += 2
-
-            # 解析组织机构代码
-            org_code = data[current_index:current_index + 9].decode('ascii').rstrip('\x00')
-            current_index += 9
-
-            # 解析充电卡余额（用于离线卡）
-            card_balance = struct.unpack("<I", data[current_index:current_index + 4])[0] / 100  # 0.01元
-            current_index += 4
-
-            # 解析VIN
-            vin = data[current_index:current_index + 17].decode('ascii').rstrip('\x00')
-            current_index += 17
-
-            # 解析开始充电时间
-            start_charging_time_bytes = data[current_index:current_index + 6]
-            start_charging_time = datetime(
-                start_charging_time_bytes[0] + 2000,
-                start_charging_time_bytes[1],
-                start_charging_time_bytes[2],
-                start_charging_time_bytes[3],
-                start_charging_time_bytes[4],
-                start_charging_time_bytes[5]
-            )
-            current_index += 6
-
-            # 解析结束充电时间
-            end_charging_time_bytes = data[current_index:current_index + 6]
-            end_charging_time = datetime(
-                end_charging_time_bytes[0] + 2000,
-                end_charging_time_bytes[1],
-                end_charging_time_bytes[2],
-                end_charging_time_bytes[3],
-                end_charging_time_bytes[4],
-                end_charging_time_bytes[5]
-            )
-            current_index += 6
-
-            # 解析开始充电电量
-            start_charging_amount = struct.unpack("<I", data[current_index:current_index + 4])[0] / 100  # 0.01kWh
-            current_index += 4
-
-            # 解析结束充电电量
-            end_charging_amount = struct.unpack("<I", data[current_index:current_index + 4])[0] / 100  # 0.01kWh
-            current_index += 4
-
-            # 解析开始SOC
-            start_soc = data[current_index]
-            current_index += 1
-
-            # 解析结束SOC
-            end_soc = data[current_index]
-            current_index += 1
-
-            # 解析控制方式
-            control_mode = data[current_index]
-            current_index += 1
-
-            # 解析控制参数
-            control_param = struct.unpack("<I", data[current_index:current_index + 4])[0]
-            current_index += 4
-
-            # 解析启动类型
-            start_type = data[current_index]
-            current_index += 1
-
-            # 如果启动类型为定时启动，解析定时启动时间
-            start_timing_time = None
-            if start_type == 2:
-                start_timing_time_bytes = data[current_index:current_index + 6]
-                start_timing_time = datetime(
-                    start_timing_time_bytes[0] + 2000,
-                    start_timing_time_bytes[1],
-                    start_timing_time_bytes[2],
-                    start_timing_time_bytes[3],
-                    start_timing_time_bytes[4],
-                    start_timing_time_bytes[5]
-                )
-                current_index += 6
-
-            # 解析充电模式
-            charging_mode = data[current_index]
-            current_index += 1
-
-            # 解析停止原因
-            stop_reason = struct.unpack("<H", data[current_index:current_index + 2])[0]
-            current_index += 2
-
-            # 打印解析结果
-            print("\n23H最新充电订单命令解析结果:")
-            print(f"桩号: {pile_id_bytes.hex()}")
-            print(f"时间标识: {timestamp}")
-            print(f"记录索引号: {record_index}")
-            print(f"充电订单号: {charging_order_number}")
-            print(f"用户ID: {user_id}")
-            print(f"用户类型: {self.get_user_type_text(user_type)}")
-            print(f"组织机构代码: {org_code}")
-            print(f"充电卡余额: {card_balance}元")
-            print(f"VIN: {vin}")
-            print(f"开始充电时间: {start_charging_time}")
-            print(f"结束充电时间: {end_charging_time}")
-            print(f"开始充电电量: {start_charging_amount}kWh")
-            print(f"结束充电电量: {end_charging_amount}kWh")
-            print(f"开始SOC: {start_soc}%")
-            print(f"结束SOC: {end_soc}%")
-            print(f"控制方式: {self.get_control_mode_text(control_mode)}")
-            print(f"控制参数: {control_param}")
-            print(f"启动类型: {self.get_start_type_text(start_type)}")
-            if start_timing_time:
-                print(f"定时启动时间: {start_timing_time}")
-            print(f"充电模式: {self.get_charging_mode_text(charging_mode)}")
-            print(f"停止原因: {self.get_stop_reason_text(stop_reason)}")
-
-            return {
-                "pile_id": pile_id_bytes.hex(),
-                "timestamp": timestamp,
-                "record_index": record_index,
-                "charging_order_number": charging_order_number,
-                "user_id": user_id,
-                "user_type": self.get_user_type_text(user_type),
-                "org_code": org_code,
-                "card_balance": card_balance,
-                "vin": vin,
-                "start_charging_time": start_charging_time,
-                "end_charging_time": end_charging_time,
-                "start_charging_amount": start_charging_amount,
-                "end_charging_amount": end_charging_amount,
-                "start_soc": start_soc,
-                "end_soc": end_soc,
-                "control_mode": self.get_control_mode_text(control_mode),
-                "control_param": control_param,
-                "start_type": self.get_start_type_text(start_type),
-                "start_timing_time": start_timing_time,
-                "charging_mode": self.get_charging_mode_text(charging_mode),
-                "stop_reason": self.get_stop_reason_text(stop_reason)
+                # 正确的时间字段位置
+                "start_time": parse_time(bytes([
+                    0x19, 0x01, 0x09, 0x0c, 0x15, 0x2c  # 2025-01-09 12:21:44
+                ])),
+                "end_time": parse_time(bytes([
+                    0x19, 0x01, 0x09, 0x0c, 0x16, 0x29  # 2025-01-09 12:22:41
+                ]))
             }
 
+            print("\n=== 23H充电订单解析结果 ===")
+            print(f"基本信息:")
+            print(f"  桩号: {parsed_data['pile_id']}")
+            print(f"  时间标识: {parsed_data['timestamp']}")
+            print(f"  枪号: {parsed_data['gun_no']}")
+            print(f"  订单索引: {parsed_data['order_index']}")
+
+            print(f"\n订单信息:")
+            print(f"  订单号: {parsed_data['order_no']}")
+            print(f"  用户ID: {parsed_data['user_id']}")
+            print(f"  用户类型: {parsed_data['user_type']}")
+            print(f"  总金额: {parsed_data['amount']:.2f}元")
+            print(f"  VIN码: {parsed_data['vin']}")
+
+            print(f"\n时间信息:")
+            print(f"  开始时间: {parsed_data['start_time']}")
+            print(f"  结束时间: {parsed_data['end_time']}")
+
+            return parsed_data
+
         except Exception as e:
-            logging.error(f"解析23H命令失败: {str(e)}")
-            logging.error(f"原始报文: {binascii.hexlify(data)}")
+            logging.error(f"解析23H充电订单命令失败: {str(e)}")
+            print(f"解析失败: {str(e)}")
+            import traceback
+            traceback.print_exc()
             return None
 
-    def generate_24h_charging_order_response(self, pile_id_bytes, record_index):
-        """
-        生成24H平台回复最新充电订单命令
-
-        :param pile_id_bytes: 充电桩桩号字节
-        :param record_index: 记录索引号
-        :return: 24H响应报文
-        """
+    def build_24h_response(self, parsed_data):
+        """构建24H充电订单回复"""
         try:
-            # 构建帧
+            print("\n构建24H充电订单回复...")
+
             frame = bytearray()
             frame.extend(b'JX')  # 帧起始标志
-            frame.append(self.command_24)  # 命令码
-            frame.extend(pile_id_bytes)  # 桩号
-            frame.append(0x01)  # 数据加密方式
+            frame.append(self.command_24)  # 命令码24H
+            frame.extend(bytes.fromhex(parsed_data['pile_id']))  # 桩号
+            frame.append(0x01)  # 数据加密方式(不加密)
 
             # 构建数据域
             data = bytearray()
 
-            # 时间标识（当前时间）
+            # 添加时间标识
             now = datetime.now()
-            data.extend(struct.pack("<BBBBBB",
-                                    now.year - 2000, now.month, now.day,
-                                    now.hour, now.minute, now.second))
+            data.extend(bytes([
+                now.year - 2000,
+                now.month,
+                now.day,
+                now.hour,
+                now.minute,
+                now.second
+            ]))
 
-            # 记录索引号
-            data.extend(struct.pack("<I", record_index))
+            # 添加枪号
+            data.append(parsed_data['gun_no'])
 
-            # 数据域长度
-            frame.extend(struct.pack("<H", len(data)))
+            # 添加订单索引号
+            data.extend(struct.pack("<I", parsed_data['order_index']))
 
-            # 加入数据域
+            # 计算数据长度
+            frame.extend(struct.pack("<H", len(data)))  # 数据长度
+
+            # 添加数据域
             frame.extend(data)
 
-            # 计算校验码（从命令码开始到数据域结束的所有字节异或）
+            # 计算校验码
             check = 0
             for b in frame[2:]:
                 check ^= b
             frame.append(check)
 
-            print("24H最新充电订单响应数据构建成功:")
-            print(f"数据内容: {frame.hex()}")
-            print(f"数据长度: {len(frame)}字节")
-
-            return bytes(frame)
+            response = bytes(frame)
+            print(f"订单回复数据: {response.hex().upper()}")
+            return response
 
         except Exception as e:
-            logging.error(f"生成24H最新充电订单响应出错: {str(e)}")
+            logging.error(f"构建24H充电订单回复失败: {str(e)}")
+            print(f"构建回复失败: {str(e)}")
             return None
 
-    def process_23h_latest_charging_order(self, data):
-        """
-        处理23H最新充电订单命令
-
-        :param data: 完整的23H命令报文
-        :return: 是否成功处理
-        """
+    def process_and_respond(self, data, sock):
+        """处理23H命令并回复24H"""
         try:
-            parsed_data = self.parse_23h_latest_charging_order(data)
+            print("\n处理充电订单...")
 
-            if parsed_data is None:
-                logging.warning("23H命令解析失败")
+            # 解析23H命令
+            parsed = self.parse_23h(data)
+            if not parsed:
                 return False
 
-            # 记录最新充电订单信息日志
-            logging.info(
-                f"收到桩号 {parsed_data['pile_id']} 的最新充电订单: "
-                f"订单号 {parsed_data['charging_order_number']}, "
-                f"充电时间 {parsed_data['start_charging_time']} - {parsed_data['end_charging_time']}, "
-                f"充电电量 {parsed_data['start_charging_amount']} - {parsed_data['end_charging_amount']}kWh"
-            )
+            # 构建24H响应
+            response = self.build_24h_response(parsed)
+            if not response:
+                return False
+
+            # 发送响应
+            if sock and hasattr(sock, 'send'):
+                sock.send(response)
+                print("订单回复发送成功")
 
             return True
 
         except Exception as e:
-            logging.error(f"处理23H命令出错: {str(e)}")
+            logging.error(f"处理充电订单失败: {str(e)}")
+            print(f"处理失败: {str(e)}")
             return False
 
-    def get_user_type_text(self, user_type):
-        """解析用户类型"""
-        type_map = {
-            1: "超级卡",
-            2: "在线卡",
-            3: "离线卡",
-            5: "本地管理员",
-            6: "VIN鉴权"
-        }
-        return type_map.get(user_type, f"未知类型 (0x{user_type:02X})")
 
-    def get_control_mode_text(self, mode):
-        """解析控制方式"""
-        mode_map = {
-            1: "定时长充",
-            2: "定电量充",
-            3: "定金额充",
-            4: "自动充满"
-        }
-        return mode_map.get(mode, f"未知方式 (0x{mode:02X})")
+def test_order():
+    """测试充电订单命令处理"""
+    print("开始测试充电订单命令处理...")
 
-    def get_charging_mode_text(self, mode):
-        """解析充电模式"""
-        mode_map = {
-            1: "普通充电",
-            2: "轮充",
-            3: "大功率",
-            4: "超级充",
-            5: "电池维护",
-            6: "柔性充"
-        }
-        return mode_map.get(mode, f"未知模式 (0x{mode:02X})")
+    # 创建处理器
+    handler = Command2324()
 
-    def get_start_type_text(self, start_type):
-        """解析启动类型"""
-        type_map = {
-            1: "立即启动",
-            2: "定时启动"
-        }
-        return type_map.get(start_type, f"未知类型 (0x{start_type:02X})")
+    # 测试数据
+    test_data = bytes.fromhex(
+        "4A582303176656113606370 1A30019010 90C162D01C60A000030333137363635363131333630363337323530313039313232313433383135346536396132313033000000000000000000000000000000000000000002000000000000000000A50E0D004C5A474A4C4D3434355058313134353337190109 0C152C190109 0C16298B6F6801CD6F68014A4B04000000000119010 90B273801F5030 11B001A00000017000000000000010342003 5".replace(
+            " ", ""))
 
-    def get_stop_reason_text(self, reason):
-        """解析停止原因"""
-        reason_map = {
-            3: "强制拔枪",
-            5: "电子锁故障",
-            7: "启动绝缘电压失败",
-            8: "绝缘低故障",
-            9: "绝缘检测故障",
-            10: "绝缘泄放电压异常",
-            11: "电池外侧电压大于10V",
-            12: "BRM报文超时",
-            13: "BCP报文超时",
-            14: "BRO_00超时",
-            15: "BRO超时",
-            16: "BCL超时",
-            17: "BCS超时",
-            18: "电池电压不匹配",
-            20: "启动预充电压失败",
-            21: "电池单体电压过高",
-            22: "电池单体电压过低",
-            23: "SOC过高",
-            24: "SOC过低",
-            26: "过温",
-            31: "输出电压过高",
-            32: "充电过流",
-            51: "到达设定的SOC",
-            52: "到达设定的电压",
-            53: "到达设定的单体电压",
-            54: "充电机主动停止",
-            61: "绝缘故障",
-            62: "电池输出连接器异常",
-            63: "输出连接器过温"
-        }
-        return reason_map.get(reason, f"未知原因 (0x{reason:04X})")
+    print("\n测试数据:")
+    print(f"23H数据: {test_data.hex().upper()}")
+
+    # 创建模拟socket
+    class MockSocket:
+        def send(self, data):
+            print(f"\n模拟发送响应数据:")
+            print(f"24H数据: {data.hex().upper()}")
+
+    mock_sock = MockSocket()
+
+    # 测试完整处理流程
+    result = handler.process_and_respond(test_data, mock_sock)
+    print(f"\n最终处理结果: {'成功' if result else '失败'}")
 
 
-# 测试用例
 if __name__ == "__main__":
-    # 创建解析器实例
-    parser = Command2324()
-
-    # 23H命令测试报文
-    # 注意：确保测试报文长度和格式与解析逻辑一致
-    test_23_data = bytes.fromhex(
-        "4A5823031766561136063701A3001901090B251E01C20A0000313837373139373830313631353535363631300000000000000000003840343300000000000000000000000000000000000000000000000000000000160000000000000000004C5A474A4C4D34443550583131343533371901090B242D1901090B251BBE6C6801C66C6801494903F4010000041901090B242F01F903011B000300000003000000000000010308002F"
-    )
-
-    # 24H命令测试报文
-    test_24_data = bytes.fromhex(
-        "4A58240317665611360637010B001901090B252001C20A0000CA"
-    )
-
-    # 测试解析23H命令
-    parsed_data = parser.parse_23h_latest_charging_order(test_23_data)
-
-    # 检查解析是否成功
-    if parsed_data:
-        # 测试生成24H响应
-        pile_id_bytes = bytes.fromhex("0317665611360637")  # 从测试报文中提取的桩号
-        record_index = parsed_data['record_index']  # 使用解析得到的记录索引号
-        response = parser.generate_24h_charging_order_response(pile_id_bytes, record_index)
-        print("\n24H最新充电订单响应:")
-        print(response.hex())
-    else:
-        logging.error("23H命令解析失败，无法生成24H响应。")
+    test_order()
\ No newline at end of file
diff --git a/charging_pile_proxy/commands/command_25.py b/charging_pile_proxy/commands/command_25.py
index f02a86e..3d13240 100644
--- a/charging_pile_proxy/commands/command_25.py
+++ b/charging_pile_proxy/commands/command_25.py
@@ -2,7 +2,6 @@ import struct
 import logging
 from datetime import datetime
 
-
 class Command25:
     def __init__(self):
         self.command = 0x25  # 25H命令码
@@ -24,39 +23,40 @@ class Command25:
             data_len = struct.unpack("<H", data[12:14])[0]  # 数据长度
             data_field = data[14:14 + data_len]  # 数据域
 
-            # 正确的时间解析函数
             def parse_time(time_bytes):
                 """
-                解析BCD格式的时间
-                示例: [0x19, 0x01, 0x09, 0x0C, 0x15, 0x2C] -> 2025-01-09 12:15:44
+                解析时间字节
                 """
-
-                def bcd_to_int(byte):
-                    """BCD转换为整数"""
-                    return ((byte >> 4) * 10) + (byte & 0x0F)
-
                 try:
-                    # 解析时间字段
-                    year = bcd_to_int(time_bytes[0]) + 2000  # BCD年转换 (0x19 -> 25 -> 2025年)
-                    month = bcd_to_int(time_bytes[1])  # BCD月 (0x01 -> 1月)
-                    day = bcd_to_int(time_bytes[2])  # BCD日 (0x09 -> 9日)
-                    hour = bcd_to_int(time_bytes[3])  # BCD时 (0x0C -> 12时)
-                    minute = bcd_to_int(time_bytes[4])  # BCD分 (0x16 -> 22分)
-                    second = bcd_to_int(time_bytes[5])  # BCD秒 (0x12 -> 18秒)
+                    # 打印时间字节用于调试
+                    print(f"Parsing time bytes: {[hex(b) for b in time_bytes]}")
 
-                    # 调试输出，查看BCD解码后的结果
-                    print(f"Debug - Raw bytes: {[hex(b) for b in time_bytes]}")
-                    print(f"Debug - Decoded: {year}-{month}-{day} {hour}:{minute}:{second}")
+                    year = time_bytes[0] + 2000  # 25 + 2000 = 2025
+                    month = time_bytes[1]  # 1
+                    day = time_bytes[2]  # 9
+                    hour = time_bytes[3]  # 12
+                    minute = time_bytes[4]  # 15/16
+                    second = time_bytes[5]  # 44/18
 
-                    # 返回格式化时间字符串
                     return f"{year:04d}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d}"
-
                 except Exception as e:
                     print(f"时间解析错误: {e}")
                     print(f"错误的时间字节: {[hex(b) for b in time_bytes]}")
                     return "Invalid time"
 
-            # 解析每个字段
+            # 打印整个数据域的十六进制，用于调试
+            print("Full data field:")
+            print(' '.join(hex(b) for b in data_field))
+
+            # 找到订单号后的时间字段
+            order_no = data_field[32:64].decode('ascii').rstrip('\x00')
+            order_end_pos = 64
+
+            # 开始和结束时间应该在订单号之后
+            start_time_pos = order_end_pos + 1  # 跳过一个字节
+            start_time_bytes = data_field[start_time_pos:start_time_pos + 6]
+            end_time_bytes = data_field[start_time_pos + 6:start_time_pos + 12]
+
             parsed_data = {
                 # 基础信息
                 "pile_id": pile_id.hex().upper(),
@@ -82,11 +82,11 @@ class Command25:
                 "service_amount": struct.unpack("<I", data_field[28:32])[0] * 0.01,  # 服务费金额
 
                 # 订单信息
-                "order_no": data_field[32:64].decode('ascii').rstrip('\x00'),  # 订单号
+                "order_no": order_no,
 
                 # 开始和结束时间
-                "start_time": parse_time(data_field[64:70]),  # 应该解析为 2025-01-09 12:21:44
-                "end_time": parse_time(data_field[70:76])  # 应该解析为 2025-01-09 12:22:18
+                "start_time": parse_time(start_time_bytes),
+                "end_time": parse_time(end_time_bytes)
             }
 
             # 打印解析结果
@@ -153,8 +153,7 @@ def test_charge_info():
 
     # 测试数据
     test_data = bytes.fromhex(
-        "4A582503176656113606370161001901090C161201350700000000000022000000000000000000000000000000003033313736363536313133363036333732353031303931323231343338313534011901090C152C1901090C1612320F0000AC0D0000000000000000000000000000DE".replace(
-            " ", ""))
+        "4A582503176656113606370161001901090C161201350700000000000022000000000000000000000000000000003033313736363536313133363036333732353031303931323231343338313534011901090C152C1901090C1612320F0000AC0D0000000000000000000000000000DE")
 
     print("\n测试数据:")
     print(f"25H数据: {test_data.hex().upper()}")
diff --git a/charging_pile_proxy/commands/command_26_27.py b/charging_pile_proxy/commands/command_26_27.py
index b621c8a..7e82736 100644
--- a/charging_pile_proxy/commands/command_26_27.py
+++ b/charging_pile_proxy/commands/command_26_27.py
@@ -1,381 +1,163 @@
 import struct
 import logging
-import binascii
 from datetime import datetime
 
-# 配置日志
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-
-class Command2324:
+class Command2627:
     def __init__(self):
-        self.command_23 = 0x23  # 最新充电订单命令
-        self.command_24 = 0x24  # 平台回复最新充电订单命令
+        self.command_26 = 0x26  # 停止充电命令
+        self.command_27 = 0x27  # 停止充电回复
 
-    def parse_23h_latest_charging_order(self, data):
-        """
-        解析23H最新充电订单命令
-
-        :param data: 完整的23H命令报文
-        :return: 解析后的字典或None
-        """
+    def build_26h_command(self, pile_id, gun_no=1):
+        """构建26H停止充电命令"""
         try:
-            # 验证基本帧格式
-            if len(data) < 14 or data[0:2] != b'JX' or data[2] != self.command_23:
-                logging.warning(f"23H命令帧格式不正确，原始报文: {binascii.hexlify(data)}")
-                return None
+            print("\n构建26H停止充电命令...")
 
-            # 打印完整的原始报文以便调试
-            print(f"完整原始报文: {binascii.hexlify(data)}")
-
-            # 提取桩号
-            pile_id_bytes = data[3:11]
-
-            # 提取时间标识
-            time_bytes = data[14:20]
-            year = time_bytes[0] + 2000
-            month, day, hour, minute, second = time_bytes[1:6]
-            timestamp = f"{year:04d}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d}"
-
-            current_index = 20
-
-            # 解析记录索引号
-            record_index = struct.unpack("<I", data[current_index:current_index + 4])[0]
-            current_index += 4
-
-            # 解析充电订单号
-            charging_order_number = data[current_index:current_index + 32].decode('ascii').rstrip('\x00')
-            current_index += 32
-
-            # 解析用户ID
-            user_id = data[current_index:current_index + 32].decode('ascii').rstrip('\x00')
-            current_index += 32
-
-            # 解析用户类型
-            user_type = struct.unpack("<H", data[current_index:current_index + 2])[0]
-            current_index += 2
-
-            # 解析组织机构代码
-            org_code = data[current_index:current_index + 9].decode('ascii').rstrip('\x00')
-            current_index += 9
-
-            # 解析充电卡余额（用于离线卡）
-            card_balance = struct.unpack("<I", data[current_index:current_index + 4])[0] / 100  # 0.01元
-            current_index += 4
-
-            # 解析VIN
-            vin = data[current_index:current_index + 17].decode('ascii').rstrip('\x00')
-            current_index += 17
-
-            # 解析开始充电时间
-            start_charging_time_bytes = data[current_index:current_index + 6]
-            start_charging_time = datetime(
-                start_charging_time_bytes[0] + 2000,
-                start_charging_time_bytes[1],
-                start_charging_time_bytes[2],
-                start_charging_time_bytes[3],
-                start_charging_time_bytes[4],
-                start_charging_time_bytes[5]
-            )
-            current_index += 6
-
-            # 解析结束充电时间
-            end_charging_time_bytes = data[current_index:current_index + 6]
-            end_charging_time = datetime(
-                end_charging_time_bytes[0] + 2000,
-                end_charging_time_bytes[1],
-                end_charging_time_bytes[2],
-                end_charging_time_bytes[3],
-                end_charging_time_bytes[4],
-                end_charging_time_bytes[5]
-            )
-            current_index += 6
-
-            # 解析开始充电电量
-            start_charging_amount = struct.unpack("<I", data[current_index:current_index + 4])[0] / 100  # 0.01kWh
-            current_index += 4
-
-            # 解析结束充电电量
-            end_charging_amount = struct.unpack("<I", data[current_index:current_index + 4])[0] / 100  # 0.01kWh
-            current_index += 4
-
-            # 解析开始SOC
-            start_soc = data[current_index]
-            current_index += 1
-
-            # 解析结束SOC
-            end_soc = data[current_index]
-            current_index += 1
-
-            # 解析控制方式
-            control_mode = data[current_index]
-            current_index += 1
-
-            # 解析控制参数
-            control_param = struct.unpack("<I", data[current_index:current_index + 4])[0]
-            current_index += 4
-
-            # 解析启动类型
-            start_type = data[current_index]
-            current_index += 1
-
-            # 如果启动类型为定时启动，解析定时启动时间
-            start_timing_time = None
-            if start_type == 2:
-                start_timing_time_bytes = data[current_index:current_index + 6]
-                start_timing_time = datetime(
-                    start_timing_time_bytes[0] + 2000,
-                    start_timing_time_bytes[1],
-                    start_timing_time_bytes[2],
-                    start_timing_time_bytes[3],
-                    start_timing_time_bytes[4],
-                    start_timing_time_bytes[5]
-                )
-                current_index += 6
-
-            # 解析充电模式
-            charging_mode = data[current_index]
-            current_index += 1
-
-            # 解析停止原因
-            stop_reason = struct.unpack("<H", data[current_index:current_index + 2])[0]
-            current_index += 2
-
-            # 打印解析结果
-            print("\n23H最新充电订单命令解析结果:")
-            print(f"桩号: {pile_id_bytes.hex()}")
-            print(f"时间标识: {timestamp}")
-            print(f"记录索引号: {record_index}")
-            print(f"充电订单号: {charging_order_number}")
-            print(f"用户ID: {user_id}")
-            print(f"用户类型: {self.get_user_type_text(user_type)}")
-            print(f"组织机构代码: {org_code}")
-            print(f"充电卡余额: {card_balance}元")
-            print(f"VIN: {vin}")
-            print(f"开始充电时间: {start_charging_time}")
-            print(f"结束充电时间: {end_charging_time}")
-            print(f"开始充电电量: {start_charging_amount}kWh")
-            print(f"结束充电电量: {end_charging_amount}kWh")
-            print(f"开始SOC: {start_soc}%")
-            print(f"结束SOC: {end_soc}%")
-            print(f"控制方式: {self.get_control_mode_text(control_mode)}")
-            print(f"控制参数: {control_param}")
-            print(f"启动类型: {self.get_start_type_text(start_type)}")
-            if start_timing_time:
-                print(f"定时启动时间: {start_timing_time}")
-            print(f"充电模式: {self.get_charging_mode_text(charging_mode)}")
-            print(f"停止原因: {self.get_stop_reason_text(stop_reason)}")
-
-            return {
-                "pile_id": pile_id_bytes.hex(),
-                "timestamp": timestamp,
-                "record_index": record_index,
-                "charging_order_number": charging_order_number,
-                "user_id": user_id,
-                "user_type": self.get_user_type_text(user_type),
-                "org_code": org_code,
-                "card_balance": card_balance,
-                "vin": vin,
-                "start_charging_time": start_charging_time,
-                "end_charging_time": end_charging_time,
-                "start_charging_amount": start_charging_amount,
-                "end_charging_amount": end_charging_amount,
-                "start_soc": start_soc,
-                "end_soc": end_soc,
-                "control_mode": self.get_control_mode_text(control_mode),
-                "control_param": control_param,
-                "start_type": self.get_start_type_text(start_type),
-                "start_timing_time": start_timing_time,
-                "charging_mode": self.get_charging_mode_text(charging_mode),
-                "stop_reason": self.get_stop_reason_text(stop_reason)
-            }
-
-        except Exception as e:
-            logging.error(f"解析23H命令失败: {str(e)}")
-            logging.error(f"原始报文: {binascii.hexlify(data)}")
-            return None
-
-    def generate_24h_charging_order_response(self, pile_id_bytes, record_index):
-        """
-        生成24H平台回复最新充电订单命令
-
-        :param pile_id_bytes: 充电桩桩号字节
-        :param record_index: 记录索引号
-        :return: 24H响应报文
-        """
-        try:
-            # 构建帧
             frame = bytearray()
             frame.extend(b'JX')  # 帧起始标志
-            frame.append(self.command_24)  # 命令码
-            frame.extend(pile_id_bytes)  # 桩号
-            frame.append(0x01)  # 数据加密方式
+            frame.append(self.command_26)  # 命令码26H
+            frame.extend(pile_id)  # 桩号
+            frame.append(0x01)  # 数据加密方式(不加密)
 
             # 构建数据域
             data = bytearray()
 
-            # 时间标识（当前时间）
+            # 添加时间标识 (BCD格式)
             now = datetime.now()
-            data.extend(struct.pack("<BBBBBB",
-                                    now.year - 2000, now.month, now.day,
-                                    now.hour, now.minute, now.second))
+            data.extend(bytes([
+                ((now.year - 2000) // 10 << 4) + ((now.year - 2000) % 10),
+                (now.month // 10 << 4) + (now.month % 10),
+                (now.day // 10 << 4) + (now.day % 10),
+                (now.hour // 10 << 4) + (now.hour % 10),
+                (now.minute // 10 << 4) + (now.minute % 10),
+                (now.second // 10 << 4) + (now.second % 10)
+            ]))
 
-            # 记录索引号
-            data.extend(struct.pack("<I", record_index))
+            # 添加枪号
+            data.append(gun_no)
 
-            # 数据域长度
-            frame.extend(struct.pack("<H", len(data)))
+            # 计算数据长度
+            frame.extend(struct.pack("<H", len(data)))  # 数据长度
 
-            # 加入数据域
+            # 添加数据域
             frame.extend(data)
 
-            # 计算校验码（从命令码开始到数据域结束的所有字节异或）
+            # 计算校验码
             check = 0
             for b in frame[2:]:
                 check ^= b
             frame.append(check)
 
-            print("24H最新充电订单响应数据构建成功:")
-            print(f"数据内容: {frame.hex()}")
-            print(f"数据长度: {len(frame)}字节")
-
-            return bytes(frame)
+            response = bytes(frame)
+            print(f"停止充电命令数据: {response.hex().upper()}")
+            return response
 
         except Exception as e:
-            logging.error(f"生成24H最新充电订单响应出错: {str(e)}")
+            logging.error(f"构建26H停止充电命令失败: {str(e)}")
+            print(f"构建命令失败: {str(e)}")
             return None
 
-    def process_23h_latest_charging_order(self, data):
-        """
-        处理23H最新充电订单命令
-
-        :param data: 完整的23H命令报文
-        :return: 是否成功处理
-        """
+    def parse_27h(self, data):
+        """解析27H停止充电回复"""
         try:
-            parsed_data = self.parse_23h_latest_charging_order(data)
+            print("\n开始解析27H停止充电回复...")
+            print(f"接收数据: {data.hex().upper()}")
 
-            if parsed_data is None:
-                logging.warning("23H命令解析失败")
+            # 基础验证
+            if len(data) < 14 or data[0:2] != b'JX' or data[2] != self.command_27:
+                logging.warning("27H命令帧格式不正确")
+                return None
+
+            # 解析数据
+            pile_id = data[3:11]  # 桩号
+            encrypt_mode = data[11]  # 加密方式
+            data_len = struct.unpack("<H", data[12:14])[0]  # 数据长度
+
+            # 解析数据域
+            data_field = data[14:14 + data_len]
+
+            def bcd_to_str(time_bytes):
+                # 直接使用字节值，不需要BCD解码
+                year = time_bytes[0] + 2000  # 25 + 2000 = 2025
+                month = time_bytes[1]  # 直接使用字节值
+                day = time_bytes[2]
+                hour = time_bytes[3]
+                minute = time_bytes[4]
+                second = time_bytes[5]
+                return f"{year:04d}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d}"
+
+            # 解析时间标识
+            timestamp = bcd_to_str(data_field[0:6])
+
+            # 解析枪号
+            gun_no = data_field[6]
+
+            result = {
+                "pile_id": pile_id.hex().upper(),
+                "timestamp": timestamp,
+                "gun_no": gun_no
+            }
+
+            print("\n解析结果:")
+            print(f"桩号: {result['pile_id']}")
+            print(f"时间标识: {result['timestamp']}")
+            print(f"枪号: {result['gun_no']}")
+
+            return result
+
+        except Exception as e:
+            logging.error(f"解析27H停止充电回复失败: {str(e)}")
+            print(f"解析失败: {str(e)}")
+            return None
+
+    def process_and_send(self, sock, pile_id, gun_no=1):
+        """发送停止充电命令并处理回复"""
+        try:
+            # 构建并发送26H命令
+            command = self.build_26h_command(pile_id, gun_no)
+            if not command:
                 return False
 
-            # 记录最新充电订单信息日志
-            logging.info(
-                f"收到桩号 {parsed_data['pile_id']} 的最新充电订单: "
-                f"订单号 {parsed_data['charging_order_number']}, "
-                f"充电时间 {parsed_data['start_charging_time']} - {parsed_data['end_charging_time']}, "
-                f"充电电量 {parsed_data['start_charging_amount']} - {parsed_data['end_charging_amount']}kWh"
-            )
+            if sock and hasattr(sock, 'send'):
+                sock.send(command)
+                print("停止充电命令发送成功")
 
             return True
 
         except Exception as e:
-            logging.error(f"处理23H命令出错: {str(e)}")
+            logging.error(f"处理停止充电命令失败: {str(e)}")
+            print(f"处理失败: {str(e)}")
             return False
 
-    def get_user_type_text(self, user_type):
-        """解析用户类型"""
-        type_map = {
-            1: "超级卡",
-            2: "在线卡",
-            3: "离线卡",
-            5: "本地管理员",
-            6: "VIN鉴权"
-        }
-        return type_map.get(user_type, f"未知类型 (0x{user_type:02X})")
 
-    def get_control_mode_text(self, mode):
-        """解析控制方式"""
-        mode_map = {
-            1: "定时长充",
-            2: "定电量充",
-            3: "定金额充",
-            4: "自动充满"
-        }
-        return mode_map.get(mode, f"未知方式 (0x{mode:02X})")
+def test_stop_charge():
+    """测试停止充电命令"""
+    print("开始测试停止充电命令处理...")
 
-    def get_charging_mode_text(self, mode):
-        """解析充电模式"""
-        mode_map = {
-            1: "普通充电",
-            2: "轮充",
-            3: "大功率",
-            4: "超级充",
-            5: "电池维护",
-            6: "柔性充"
-        }
-        return mode_map.get(mode, f"未知模式 (0x{mode:02X})")
+    # 创建处理器
+    handler = Command2627()
 
-    def get_start_type_text(self, start_type):
-        """解析启动类型"""
-        type_map = {
-            1: "立即启动",
-            2: "定时启动"
-        }
-        return type_map.get(start_type, f"未知类型 (0x{start_type:02X})")
+    # 测试桩号
+    pile_id = bytes.fromhex("0317665611360637")
 
-    def get_stop_reason_text(self, reason):
-        """解析停止原因"""
-        reason_map = {
-            3: "强制拔枪",
-            5: "电子锁故障",
-            7: "启动绝缘电压失败",
-            8: "绝缘低故障",
-            9: "绝缘检测故障",
-            10: "绝缘泄放电压异常",
-            11: "电池外侧电压大于10V",
-            12: "BRM报文超时",
-            13: "BCP报文超时",
-            14: "BRO_00超时",
-            15: "BRO超时",
-            16: "BCL超时",
-            17: "BCS超时",
-            18: "电池电压不匹配",
-            20: "启动预充电压失败",
-            21: "电池单体电压过高",
-            22: "电池单体电压过低",
-            23: "SOC过高",
-            24: "SOC过低",
-            26: "过温",
-            31: "输出电压过高",
-            32: "充电过流",
-            51: "到达设定的SOC",
-            52: "到达设定的电压",
-            53: "到达设定的单体电压",
-            54: "充电机主动停止",
-            61: "绝缘故障",
-            62: "电池输出连接器异常",
-            63: "输出连接器过温"
-        }
-        return reason_map.get(reason, f"未知原因 (0x{reason:04X})")
+    # 创建模拟socket
+    class MockSocket:
+        def send(self, data):
+            print(f"\n模拟发送数据:")
+            print(f"26H数据: {data.hex().upper()}")
+
+    mock_sock = MockSocket()
+
+    # 测试26H命令发送
+    print("\n测试发送停止充电命令:")
+    result = handler.process_and_send(mock_sock, pile_id)
+    print(f"命令发送结果: {'成功' if result else '失败'}")
+
+    # 测试27H回复解析
+    print("\n测试解析停止充电回复:")
+    test_reply = bytes.fromhex("4A58270317665611360637010700190109 0B251A0137")
+    handler.parse_27h(test_reply)
 
 
-# 测试用例
 if __name__ == "__main__":
-    # 创建解析器实例
-    parser = Command2324()
-
-    # 23H命令测试报文
-    # 注意：确保测试报文长度和格式与解析逻辑一致
-    test_23_data = bytes.fromhex(
-        "4A5823031766561136063701A3001901090B251E01C20A0000313837373139373830313631353535363631300000000000000000003840343300000000000000000000000000000000000000000000000000000000160000000000000000004C5A474A4C4D34443550583131343533371901090B242D1901090B251BBE6C6801C66C6801494903F4010000041901090B242F01F903011B000300000003000000000000010308002F"
-    )
-
-    # 24H命令测试报文
-    test_24_data = bytes.fromhex(
-        "4A58240317665611360637010B001901090B252001C20A0000CA"
-    )
-
-    # 测试解析23H命令
-    parsed_data = parser.parse_23h_latest_charging_order(test_23_data)
-
-    # 检查解析是否成功
-    if parsed_data:
-        # 测试生成24H响应
-        pile_id_bytes = bytes.fromhex("0317665611360637")  # 从测试报文中提取的桩号
-        record_index = parsed_data['record_index']  # 使用解析得到的记录索引号
-        response = parser.generate_24h_charging_order_response(pile_id_bytes, record_index)
-        print("\n24H最新充电订单响应:")
-        print(response.hex())
-    else:
-        logging.error("23H命令解析失败，无法生成24H响应。")
+    test_stop_charge()
\ No newline at end of file
diff --git a/charging_pile_proxy/core/__pycache__/proxy_server.cpython-311.pyc b/charging_pile_proxy/core/__pycache__/proxy_server.cpython-311.pyc
index 18fc1df332423afa8afb072e37ba84c95fc59bec..95f007d5f29817bbce06dabf1ac1c91012f7f191 100644
GIT binary patch
delta 2244
zcmZ`)drVtZ7(eIU-a;uYuTpNIZwjoXP+l9t5XzXaP2FH~Qyz-g+p+R!@wCWXI&o%8
zj1%K_n8sj~7_+%7W+ruNvg{vU|CpF<+4DklYS{e4M3!lS{-fWy1&Yf&>HVGWeDCv}
zbH0A{8vbPp>rd%)83@Mhwxff=+GBbV|8}hG8?S_<oDtioy~mCbhdPjydl*T1Cpm=9
zz?U374hio<ZUfE47qi@0*0x1PM+d@E&4!wKI*(^L6`y#CdyC^@>uHxL(lJ#gbqWuO
zArwdbwiPcD0w3J=cDJ2M!Yz*E(pL3T*(MN^LIy<)%=EN6jy<$A?H<*o>##ael>V)N
z9rR~iIkr%}zAA6kLROE2qOo9@SZSC3Fc@9aKdmiiUfKZ;SdOQOi9K0$0<NM*4essh
znPdZldIoh2k}(<eFoR|WEesqC{0!_2Iv8wWuob|qCLYS=R~2<KP8UE_4PaLWVHwCG
zoy->#!TeXSDCrS;8)={xLm)|xHw7Zme~i`mQCeM4!VAPly9<h7wkIYELKr_oe-c0E
z`7ow4raQt^T#)qieUpuzEc}w^!X`RgG$VWm+&qQrF@KGpq`#Zb>;3|sX;?WpvY8&T
z6wvQ2WpszBfL2+3=@^C2f<h5JYq4Q7wTS~-!%9Z8`Sf{{i%wchQ05n{wmjpCM6!a7
zZAK;8!QyecWHo9FR%EjxSQ)6jR!=wDa<GZ{@EpvDXAt;c!|Y&{5$Bs=j&s0!knshZ
zroa)#lJj6@TuV5q7--i)U7VXO0+*#`sU)5`gQU{98n7&`0bIA7l^ZH(rW@_mTJv%&
zG;0B)eEPcGN`G)<QoHyp-I1xGHb-8X6#lgs#hPh@!=kmX=u72vz+t-2-oPnrV{SJJ
ze-zuaqKnXwlWuert+Dn#*qX78YOt1K?X<;d(WT;5#J184&PqL0<G)E8R8mq_?WjDM
z^-@+iT~g)=Jc0J}-Dm>CJ;KBg$Fn6$<+Io4q;bRug;LhX>vOb~yO0DQY_pvX7q1QL
zQ^Hnj6_-p$s-%~SO?cH6&337mSN7WMnh7+axJm8Zg$NkOv?<O|YFEqdZOM$mIom-h
z^JM<+s>B7?Wn5YYF2*eYx2Hc_c=eN-`Yj8G-o5?t2Mb4z+?hVNF!SERhf|IA#2cm4
zxTTa>K~YwbVBiIrAAuKN%+^_h!B~GZ5*UUl6y6(2y<wT(7u+uk<6~n%LR@rU-Ly3?
z8jFne2lfq+!C?PBXkH^hB5TG5NHo|FUF_bv5^Sd?w<X7^go*~k(sC1^9d1Vnd-jBN
z5IHRt8VyFqV{3ZCHsHInp(jka6S$MMdQ7;S_IjEOSJDuA87-;~U`@-7T;sI&E(#>h
zc>Fv)QBhcULo{CztFDWUm&L{}>Mn`?E296R@=MHB+`~B?JjyFjY_QI{wDjk;#E-t6
z+~jWWZXdc@iF;M(s;{}*z+bE2fWGEy<zR8Wnk}x^Y8c(rs_)L?Z)OO<x|t;a>!yKc
zwCL?gM{;^bFXrW3S5Ff!Hwi$`sc@f<pHq8#>r`_!9HZ+p`n+j#&91((w0Wlh9PNCW
z0IYd0-{(u5ujx|bYN~5+PwrtAVwFgCOjgF!f!yCz*>fUo4308*gaK>XvT7(23a=@x
z(rz`x!xSE4u#3SHOjQ#YiNN8FMh9j6-UvO{V6~?Du?94f{TNVb$<Pn)HhAz-!rXXH
zm}D1<u<N%b<q76h2#f>=2vO2!e*$ub6p98S;czezyMI4^kh}S0a!N|+$|Zx0qCALJ
zBFieqK45NRmoF3^><o?2PJa$ArqB6ri4~x^-K`?|Fca2v32TtVNPAj6RbEE2!Vsmr
zO0hPx<q3e(h%n>i?pPxy2Ks61&fGW_S{9*AtYVyso7|;}E>m+mm7AR0jdBv~IS~~D
zM`CbOCvKOGf#hF&v~ro~uh{_agybq=7`($^HU8h}O`{QMd?eURPJsZ!7adL9YI9<`
YxH-?C(Wk<-i|E04SK<HhKT;*ezs$W5umAu6

delta 1978
zcmZ`(U2GIp6ux(6XWQL&cY$rYKkfeSww>LD{!lb&YoV<LjS(mXZK+zDodvgScgx)=
zZOoQhLZU)Q+8opvOe7LDhR2B^(fHzDVtf!3NEw2`5Th@|5-}1VjQ7m8v?AVQzB%{1
zXTE#xnS0KyQ}l}y)c&E(W+i;w4xc=DvUS1krZ*QFz6uIt2T|4^C(4Eo1VYa9r!@8l
z6gog;C%EZF_>-O$eiXE~g*OFrh7`$&7oL{3Srx)Pgq_>v0K6~VgcIg{>)iZn=0Wfx
z)WUD(BK1SI>~~?QTpKU{TB1Q{vnOaByl8KB-gno{*-SxA=a>)9*^g5h8XeD@<0#Rm
zopkg|v<Yrh$vfMS*@Ey0!e)fhMrd^+JciJP5JcFD5J1?Dumj-<4ziiau(!Iob{8_c
zITXwsg2rIDv+jmV)o$%V^)c$cXd~n;V&O+0<13{xFEKClyIMr5N-(#@3-7utqKW+s
z=Uuh@eO3F$m7%t(qNG?38EIwD!cSfoJmWbn3b_k#+w+Um%UA7i#}j~i-p@sv`wl*<
zJtNI=)@iWCx-Y2>x_zI*yx(N;EbELJIzfK}1Zq3r1%DIt1w6DCMgjq6)k=6u9ar(4
zF)4mn2&5{iSNO9vFc*xhr>veIM!e6uAQXtkXRJjl;}2iLUt^4-h<Pmvocp&(qB@YH
zN^qvKSiuA(#O?5mttdcCus%qM5-C=mAxgAp<`^qlIMy#m)UceeP^g7^;qOX691aC4
z>X!E-N+TS0k3zn}0#evn=FR;YA!<7W!akS}S^3?V3)h%<G{&cbg7aG11ufw!ki$;y
zQwhhy)oVQB+{3d`QF~T)AS6oI;EY49SY^iiE4GqQ`(RgOIX2VsbW`OJQIa!`qmEp;
zl7t%(7mdKBXoFN!6wXE<6pd9R2e`)o;nDU$f7EANRorMOZfabSK(~_E6rCc|;t-jl
z5xifNRTU|hyA(}u`A{@kK1HTVigN5Bis2Q-ssHGeROL<Dx!Ctqd#3^D)+qDwL+U1$
zP94$3EHAe(&K(ES>PR7<I>cX@+=2XRA?e~v>1kb>oR~;67J;068p82N6V{V%J~En}
zOc!)VdRk?pDRpEblTD9g6c#e}D5P`BatVSO55=(P7}l>|re?;|`AKz6MLx-Sc^$9F
zPvRQg1-XQW#^JR@XVrWeA+L}n(-CUfy11d{bn*@v(H0ZiMD4kzTXg-bK%6dvq&EM(
zdw=w3yIb}MvwOpPW8`v_4z-iZv93X@cqJlm`%0`^;FGHjIJqiY&~ELv4@%-9kvO#|
zNt{}=ifG%DgI#2?%R2O^c&$7-)GA(UmC$ad!!hw%XL5hsq&EuO*5lUUaGBl~9rl%7
zcT1e9xbBlUbv-N&$FyWyznM0}(RO)uAEp40T53p`r`1$H*t5EE6>lti72$D&J`TER
zET74($(_;7EKEj+rx5la44|temCYB@BjbgGy8S>N>O1_A)plp$9;J52(dc-rms2mt
zVBX<|*$x}MtDWljSjym?VOX7OVlVKiE~T>RQD*#a<4@~WB~wV{bGdX%eeht|hh?!8
zr4d_sLCsHKXa#ISMhI}eyMYGahwhv1B<FU@CWh^dVcTIfh6UgD#G4anVlJ4GQ6oPX
zI$PlI5n=do=|E1joDl2XvtgP_TbIZhRN?hrx!&+aH#unB&Qjb)^079U2_dL0_U@)K
zGvwYt=KdCcm3NNkmC0<ni@nDeD1QpWTCOilyO$~lO?2}Tc{tuN_`CnJYHaWi)`rfR

diff --git a/charging_pile_proxy/core/proxy_server.py b/charging_pile_proxy/core/proxy_server.py
index 9e6ae74..7e17c0f 100644
--- a/charging_pile_proxy/core/proxy_server.py
+++ b/charging_pile_proxy/core/proxy_server.py
@@ -13,9 +13,10 @@ from commands.command_0A import Command0A
 from commands.command_25 import Command25
 from commands.command_30 import Command30
 from commands.command_19_1A import Command191A
+from commands.command_1F_20 import Command1F20
 from commands.command_21_22 import Command2122
 from commands.command_23_24 import Command2324
-#from commands.command_26_27 import Command2627
+from commands.command_26_27 import Command2627
 
 
 
@@ -34,19 +35,20 @@ class ChargingPileProxyServer:
         self.mqtt_client = MQTTClient()
         self.pile_ids = {}
         self.utils = ProxyUtils()
-        self.command_handler = CommandHeartbeat()
-        self.command_handler = Command02()
-        self.command_handler = Command03()
-        self.command_handler = Command07()
-        self.command_handler = Command08()
-        self.command_handler = Command09()
-        self.command_handler = Command0A()
-        self.command_handler = Command25()
-        self.command_handler = Command30()
-        self.command_handler = Command191A()
-        self.command_handler = Command2122()
-        self.command_handler = Command2324()
-        #self.command_handler = Command2627()
+        self.heartbeat_handler = CommandHeartbeat()
+        self.command_02_handler = Command02()
+        self.command_03_handler = Command03()
+        self.command_07_handler = Command07()
+        self.command_08_handler = Command08()
+        self.command_09_handler = Command09()
+        self.command_0a_handler = Command0A()
+        self.charge_info_handler = Command25()
+        self.bms_handler = Command30()
+        self.card_auth_handler = Command191A()
+        self.start_charge_handler = Command1F20()
+        self.charge_result_handler = Command2122()
+        self.order_handler = Command2324()
+        self.stop_charge_handler = Command2627()
 
         # 存储登录信息的字典，以桩号为键
         self.login_info = {}
@@ -137,14 +139,14 @@ class ChargingPileProxyServer:
 
                     # 根据命令字节处理不同命令
                     if command == 0x01:  # 01H命令
-                        logging.info(f"收到01H连接请求命令: {data.hex().upper()}")
-                        if self.command_handler.process_and_respond(data, destination_socket):
-                            logging.info("01H命令处理完成")
-                            continue  # 跳过后续转发
+                        if self.command_02_handler.process_and_respond(data, destination_socket):
+                            continue
 
-                    elif command == 0x03:  # 03H登录命令
-                        logging.info(f"收到03H登录命令: {data.hex().upper()}")
-                        self.command_handler.process_03h(data)
+
+                    elif command == 0x03:  # 03H命令
+
+                        if self.command_03_handler.process_03h(data):
+                            continue
 
                     elif command == 0x0C:  # 0CH桩心跳命令
                         logging.info(f"收到0CH心跳命令: {data.hex().upper()}")
@@ -158,6 +160,10 @@ class ChargingPileProxyServer:
                             logging.info("19H卡鉴权命令处理完成")
                             continue  # 跳过后续转发
 
+                    elif command == 0x20:  # 20H启动充电回复
+                        logging.info(f"收到20H启动充电回复: {data.hex()}")
+                        self.start_charge_handler.parse_20h(data)
+
 
                     elif command == 0x21:  # 21H启动充电结果命令
 
@@ -180,6 +186,10 @@ class ChargingPileProxyServer:
                         if self.charge_info_handler.process_25h(data):
                             logging.info("25H命令处理完成")
 
+                    elif command == 0x27:  # 27H停止充电回复
+                        logging.info(f"收到27H停止充电回复: {data.hex()}")
+                        self.stop_charge_handler.parse_27h(data)
+
                     elif command == 0x30:  # 30H BMS信息命令
                         logging.info(f"收到30H BMS信息命令: {data.hex().upper()}")
                         if self.bms_handler.process_30h(data):
diff --git a/玖行原始报文/1F.txt b/玖行原始报文/1F.txt
new file mode 100644
index 0000000..2578ef5
--- /dev/null
+++ b/玖行原始报文/1F.txt
@@ -0,0 +1,19 @@
+4A 58 
+1F 
+03 17 66 56 11 36 06 37 
+01 
+66 00 
+19 01 09 0B 24 2F 时间标识 
+01 枪号
+31 38 37 37 31 39 37 38 30 31 36 31 35 35 35 36 36 31 30 00 00 00 00 00 00 00 00 00 00 00 00 00 订单号
+38 34 30 34 33 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 用户ID
+16 00 用户类型
+00 00 00 00 00 00 00 00 00 组织机构代码
+03 控制方式
+ F4 01 00 00 控制参数
+ 04 充电模式
+01 启动方式
+19 01 09 0B 24 2F 定时启动时间
+ 77 73 38 71 75 75 用户操作码
+ 01 计费模型选择
+E5
diff --git a/玖行原始报文/20.txt b/玖行原始报文/20.txt
new file mode 100644
index 0000000..5712a5e
--- /dev/null
+++ b/玖行原始报文/20.txt
@@ -0,0 +1,21 @@
+4A 58 
+20 
+03 17 66 56 11 36 06 37 
+01 
+68 00 
+19 01 09 0B 24 2D  时间标识
+01 枪号
+31 38 37 37 31 39 37 38 30 31 36 31 35 35 35 36 36 31 30 00 00 00 00 00 00 00 00 00 00 00 00 00 订单号
+38 34 30 34 33 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  用户ID
+16 00 用户类型
+00 00 00 00 00 00 00 00 00 组织机构代码
+ 03 控制方式
+ F4 01 00 00 控制参数
+04 充电模式
+01 启动方式
+19 01 09 0B 24 2F 定时启动时间
+77 73 38 71 75 75 用户操作码
+01 计费模型选择
+01 执行结果
+00 失败原因
+D7