comm.cpp

来自「这是一个在正实际应用当中运行的电力监控系统软件源代码」· C++ 代码 · 共 682 行 · 第 1/2 页

CPP
682 行
字号
12
    if ((OutputReadP[CommNo]-OutputWriteP[CommNo]+WriteCommBuffLen)%WriteCommBuffLen<8) {GlobalUnlock(hChannelParamMem);return 0;}
    if (OutputCommMem[CommNo]==NULL) {GlobalUnlock(hChannelParamMem);return 0;}
    BYTE FAR *TxBuff=(BYTE FAR *)GlobalLock(OutputCommMem[CommNo]);
    *(TxBuff+(OutputWriteP[CommNo]+0)%WriteCommBuffLen)=0xBE;
    *(TxBuff+(OutputWriteP[CommNo]+1)%WriteCommBuffLen)=0x7D;
    *(TxBuff+(OutputWriteP[CommNo]+2)%WriteCommBuffLen)=ChNo&1;
    *(TxBuff+(OutputWriteP[CommNo]+3)%WriteCommBuffLen)=0x85;
    *(TxBuff+(OutputWriteP[CommNo]+4)%WriteCommBuffLen)=(ChP+ChNum)->TczPara.ModemStatus;
    *(TxBuff+(OutputWriteP[CommNo]+5)%WriteCommBuffLen)=0x00;
    *(TxBuff+(OutputWriteP[CommNo]+6)%WriteCommBuffLen)=Lpc(TxBuff,OutputWriteP[CommNo]+2,4,WriteCommBuffLen);
    *(TxBuff+(OutputWriteP[CommNo]+7)%WriteCommBuffLen)=0x16;
    OutputWriteP[CommNo]=(OutputWriteP[CommNo]+8)%WriteCommBuffLen;
    GlobalUnlock(OutputCommMem[CommNo]);
    GlobalUnlock(hChannelParamMem);
    return 1;
}
/******************************************************/
/******************************************************/
void TCommWindow::ReadCommProc()
{
int Cards=syscfg->GetCommCardNums();
int i,j,Len,ii,iii;
BYTE CHANEL=0xff,CHANEL1,CHANEL2;
ChP = (CHANNELPARAM FAR *) GlobalLock(hChannelParamMem);
    for (i=1;i<=Cards*8+2;i++)
        {
        if (InputCommMem[i]==NULL) continue;
        if (((InputWriteP[i]-InputReadP[i]+ReadCommBuffLen)%ReadCommBuffLen)<8) continue;
        if ( CalChNum(i)==0xff || CalChNum(i)>=TotalChNum || (ChP+CalChNum(i))->CHType!=2) continue;
        BYTE far *RecBuff=(BYTE FAR *)GlobalLock(InputCommMem[i]);
        while ((InputWriteP[i]-InputReadP[i]+ReadCommBuffLen)%ReadCommBuffLen>=8)
            {
                if (*(RecBuff+InputReadP[i]%ReadCommBuffLen)!=0xBE ||
                   *(RecBuff+(InputReadP[i]+1)%ReadCommBuffLen)!=0x7D)
                   {
                        InputReadP[i]=(++InputReadP[i])%ReadCommBuffLen;
                        continue;
                   }
                CHANEL1=CommPara[i-1].CHANEL1;CHANEL2=CommPara[i-1].CHANEL2;
                CHANEL=0xff;
                if (*(RecBuff+(InputReadP[i]+2)%ReadCommBuffLen)==0) CHANEL=CHANEL1;
                if (*(RecBuff+(InputReadP[i]+2)%ReadCommBuffLen)==1) CHANEL=CHANEL2;
                if (CHANEL>=TotalChNum) {InputReadP[i]=InputWriteP[i]=0;break;}
                if (!(ChP+CHANEL)->CHValidFlag) {InputReadP[i]=InputWriteP[i]=0;break;}
                if ( (ChP+CHANEL)->CHType!=2) break;
                (ChP+CHANEL)->TczPara.ModemStatus=*(RecBuff+(InputReadP[i]+4)%ReadCommBuffLen);
                Len=*(RecBuff+(InputReadP[i]+5)%ReadCommBuffLen);
                if (((InputWriteP[i]-InputReadP[i]+ReadCommBuffLen)%ReadCommBuffLen)<Len+8) break;
                BYTE LPC=Lpc(RecBuff,InputReadP[i]+2,Len+4,ReadCommBuffLen);


                if (LPC==*(RecBuff+(InputReadP[i]+Len+6)%ReadCommBuffLen))
                   {
                    (ChP+CHANEL)->TczPara.ModemStatus=*(RecBuff+(InputReadP[i]+4)%ReadCommBuffLen);
                         if (*(RecBuff+(InputReadP[i]+3)%ReadCommBuffLen)==1)
                            {
                                if (GetSetCommNo==i && GetSetChNo==*(RecBuff+(InputReadP[i]+2)%ReadCommBuffLen) && GetSetFlag==1)
                                   {
                                        COMMPARAMESSAGE *TEMP;
                                        TEMP=(COMMPARAMESSAGE *)(RecBuff+(InputReadP[i]+6)%ReadCommBuffLen);
                                        (ChP+Radio)->TczPara=*TEMP;
                                        GetSetFlag=2;
                                   }
                            }
                         else if (*(RecBuff+(InputReadP[i]+3)%ReadCommBuffLen)==0xf)
                            {
                                Freq=(*(RecBuff+(InputReadP[i]+6)%ReadCommBuffLen))*256+*(RecBuff+(InputReadP[i]+7)%ReadCommBuffLen);
                            }
                         else

                            {
                                BYTE FAR *rxb=(ChP+CHANEL)->RecBuff;
                                WORD rdp=(ChP+CHANEL)->RxReadP;
                                WORD wrp=(ChP+CHANEL)->RxWriteP;
                                if ((-wrp+rdp+(ChP+CHANEL)->RxBuffLen-1)%(ChP+CHANEL)->RxBuffLen>=Len)
                                   {
                                        for (iii=0;iii<Len;iii++)
                                            {
                                                *(rxb+(wrp+iii)%(ChP+CHANEL)->RxBuffLen)=*(RecBuff+(InputReadP[i]+iii+6)%ReadCommBuffLen);//6
                                            }
                                        (ChP+CHANEL)->RxWriteP=(wrp+Len)%(ChP+CHANEL)->RxBuffLen;
                                        //InputReadP[i]=(InputReadP[i]+Len+8)%ReadCommBuffLen;
                                   }
                            }
                   }
                InputReadP[i]=(InputReadP[i]+Len+8)%ReadCommBuffLen;
            }
        GlobalUnlock(InputCommMem[i]);
        }

    for (i=1;i<=Cards*8+2;i++)
        {
        if (InputCommMem[i]==NULL) continue;
        if (((InputWriteP[i]-InputReadP[i]+ReadCommBuffLen)%ReadCommBuffLen)<6) continue;
        CHANEL=CalChNum(i);
        if (CHANEL==0xff || CHANEL>=TotalChNum) continue;
        if ((ChP+CHANEL)->CHType!=1 || !(ChP+CHANEL)->CHValidFlag) continue;
        BYTE far *RecBuff=(BYTE FAR *)GlobalLock(InputCommMem[i]);
        while ((InputWriteP[i]-InputReadP[i]+ReadCommBuffLen)%ReadCommBuffLen>=6)
            {
            Len=(InputWriteP[i]-InputReadP[i]+ReadCommBuffLen)%ReadCommBuffLen;
                BYTE FAR *rxb=(ChP+CHANEL)->RecBuff;
                WORD rdp=(ChP+CHANEL)->RxReadP;
                WORD wrp=(ChP+CHANEL)->RxWriteP;
                if ((-wrp+rdp+(ChP+CHANEL)->RxBuffLen-1)%(ChP+CHANEL)->RxBuffLen>=Len)
                   {
                        for (iii=0;iii<Len;iii++)
                            {
                                *(rxb+(wrp+iii)%(ChP+CHANEL)->RxBuffLen)=*(RecBuff+(InputReadP[i]+iii)%ReadCommBuffLen);//6
                            }
                        (ChP+CHANEL)->RxWriteP=(wrp+Len)%(ChP+CHANEL)->RxBuffLen;
                        InputReadP[i]=(InputReadP[i]+Len)%ReadCommBuffLen;
                   }
            }
        GlobalUnlock(InputCommMem[i]);
        }

GlobalUnlock(hChannelParamMem);
}
/******************************************************/
/******************************************************/
void TCommWindow::WriteCommProc()
{
ChP = (CHANNELPARAM FAR *) GlobalLock(hChannelParamMem);
int i,ii;
BYTE CommNo,ChNo;
WORD Len;
BYTE FAR *txb;
BYTE FAR *TxBuff;
WORD rp;
for (i=0;i<TotalChNum;i++)
    {
        if ((ChP+i)->CHType!=2 || !((ChP+i)->CHValidFlag)) continue;
        if ((ChP+i)->TxReadP==(ChP+i)->TxWriteP) continue;
        Len=((ChP+i)->TxWriteP-(ChP+i)->TxReadP+(ChP+i)->TxBuffLen)%(ChP+i)->TxBuffLen;
        Len= ( (Len < 60) ? Len : 60);
        CommNo=(ChP+i)->SIOOrd;ChNo=(ChP+i)->ChNoInComm;
        if (OutputCommMem[CommNo]==NULL) {continue;}
        if (((OutputReadP[CommNo]-OutputWriteP[CommNo]+WriteCommBuffLen-1)%WriteCommBuffLen)<Len+8) continue;
        if ((ChP+i)->TczPara.ModemStatus==0) continue;
        txb=(ChP+i)->SendBuff;
        rp=(ChP+i)->TxReadP;
        TxBuff=(BYTE FAR *)GlobalLock(OutputCommMem[CommNo]);
        *(TxBuff+(OutputWriteP[CommNo])%WriteCommBuffLen)=0xBE                      ;
        *(TxBuff+(OutputWriteP[CommNo]+1)%WriteCommBuffLen)=0x7D;
        *(TxBuff+(OutputWriteP[CommNo]+2)%WriteCommBuffLen)=ChNo&1;
        *(TxBuff+(OutputWriteP[CommNo]+3)%WriteCommBuffLen)=0x80;
        *(TxBuff+(OutputWriteP[CommNo]+4)%WriteCommBuffLen)=(ChP+i)->TczPara.ModemStatus;
        *(TxBuff+(OutputWriteP[CommNo]+5)%WriteCommBuffLen)=Len;
        for (ii=0;ii<Len;ii++)
            {
                *(TxBuff+(OutputWriteP[CommNo]+ii+6)%WriteCommBuffLen)=*(txb+(rp+ii)%(ChP+i)->TxBuffLen);
            }
        BYTE LPC=Lpc(TxBuff,OutputWriteP[CommNo]+2,Len+4,WriteCommBuffLen);
        *(TxBuff+(OutputWriteP[CommNo]+6+Len)%WriteCommBuffLen)=LPC;
        *(TxBuff+(OutputWriteP[CommNo]+7+Len)%WriteCommBuffLen)=0x16;
        OutputWriteP[CommNo]=(OutputWriteP[CommNo]+Len+8)%WriteCommBuffLen;
        (ChP+i)->TxReadP=(rp+Len)%(ChP+i)->TxBuffLen;
        if ((ChP+i)->TxReadP==(ChP+i)->TxWriteP)  (ChP+i)->TxReadP=(ChP+i)->TxWriteP=0;
        GlobalUnlock(OutputCommMem[CommNo]);
    }

for (i=0;i<TotalChNum;i++)
    {
        if ((ChP+i)->CHType!=1 || !((ChP+i)->CHValidFlag)) continue;
        if ((ChP+i)->TxReadP==(ChP+i)->TxWriteP) continue;
        if ((ChP+i)->TxReadP-(ChP+i)->TxWriteP==-1) {(ChP+i)->TxWriteP=(ChP+i)->TxReadP=0;continue;}
        Len=((ChP+i)->TxWriteP-(ChP+i)->TxReadP+(ChP+i)->TxBuffLen)%(ChP+i)->TxBuffLen;
        CommNo=(ChP+i)->SIOOrd;ChNo=(ChP+i)->ChNoInComm;
        if (OutputCommMem[CommNo]==NULL) {continue;}
		if (((OutputReadP[CommNo]-OutputWriteP[CommNo]+WriteCommBuffLen-1)%WriteCommBuffLen)<Len) continue;
        if (OutputReadP[CommNo]!=OutputWriteP[CommNo]) continue;
        txb=(ChP+i)->SendBuff;
        rp=(ChP+i)->TxReadP;
        TxBuff=(BYTE FAR *)GlobalLock(OutputCommMem[CommNo]);
        for (ii=0;ii<Len;ii++)
            {
                *(TxBuff+(OutputWriteP[CommNo]+ii)%WriteCommBuffLen)=*(txb+(rp+ii)%(ChP+i)->TxBuffLen);
            }
        OutputWriteP[CommNo]=(OutputWriteP[CommNo]+Len)%WriteCommBuffLen;
        (ChP+i)->TxReadP=(rp+Len)%(ChP+i)->TxBuffLen;
        GlobalUnlock(OutputCommMem[CommNo]);
    }


GlobalUnlock(hChannelParamMem);
}
/******************************************************/
BYTE Lpc(BYTE FAR *Buf,WORD Ptr,BYTE Len,WORD Mode)
{
BYTE temp=0;
for (int i=0;i<Len;i++)
    {
        temp ^=*(Buf+(Ptr+i)%Mode);
    }
return temp^=0xff;
}
/******************************************************/
BOOL GetModemSet(BYTE ChNum)
{
    ChP = (CHANNELPARAM FAR *) GlobalLock(hChannelParamMem);
    if ((ChP+ChNum)->CHType!=2) {GlobalUnlock(hChannelParamMem);return 0;}
    BYTE CommNo,ChNo;
    GetSetCommNo=CommNo=(ChP+ChNum)->SIOOrd;
    GetSetChNo=ChNo=(ChP+ChNum)->ChNoInComm;

    if ((OutputReadP[CommNo]-OutputWriteP[CommNo]+WriteCommBuffLen)%WriteCommBuffLen<8) {GlobalUnlock(hChannelParamMem);return 0;}
    if (OutputCommMem[CommNo]==NULL) {GlobalUnlock(hChannelParamMem);return 0;}
    BYTE FAR *TxBuff=(BYTE FAR *)GlobalLock(OutputCommMem[CommNo]);
    *(TxBuff+(OutputWriteP[CommNo]+0)%WriteCommBuffLen)=0xBE;
    *(TxBuff+(OutputWriteP[CommNo]+1)%WriteCommBuffLen)=0x7D;
    *(TxBuff+(OutputWriteP[CommNo]+2)%WriteCommBuffLen)=ChNo&1;
    *(TxBuff+(OutputWriteP[CommNo]+3)%WriteCommBuffLen)=0x82;
    *(TxBuff+(OutputWriteP[CommNo]+4)%WriteCommBuffLen)=(ChP+ChNum)->TczPara.ModemStatus;
    *(TxBuff+(OutputWriteP[CommNo]+5)%WriteCommBuffLen)=0x00;
    *(TxBuff+(OutputWriteP[CommNo]+6)%WriteCommBuffLen)=Lpc(TxBuff,OutputWriteP[CommNo]+2,4,WriteCommBuffLen);
    *(TxBuff+(OutputWriteP[CommNo]+7)%WriteCommBuffLen)=0x16;
    OutputWriteP[CommNo]=(OutputWriteP[CommNo]+8)%WriteCommBuffLen;
    GlobalUnlock(OutputCommMem[CommNo]);
    GlobalUnlock(hChannelParamMem);
    return 1;
}

BOOL EnReadSelf(BYTE ChNum)
{
    DiReadSelf(ChNum);
    ChP = (CHANNELPARAM FAR *) GlobalLock(hChannelParamMem);
    if ((ChP+ChNum)->CHType!=2) {GlobalUnlock(hChannelParamMem);return 0;}
    BYTE CommNo,ChNo;
    GetSetCommNo=CommNo=(ChP+ChNum)->SIOOrd;
    GetSetChNo=ChNo=(ChP+ChNum)->ChNoInComm;

    if ((OutputReadP[CommNo]-OutputWriteP[CommNo]+WriteCommBuffLen)%WriteCommBuffLen<8) {GlobalUnlock(hChannelParamMem);return 0;}
    if (OutputCommMem[CommNo]==NULL) {GlobalUnlock(hChannelParamMem);return 0;}
    BYTE FAR *TxBuff=(BYTE FAR *)GlobalLock(OutputCommMem[CommNo]);
    *(TxBuff+(OutputWriteP[CommNo]+0)%WriteCommBuffLen)=0xBE;
    *(TxBuff+(OutputWriteP[CommNo]+1)%WriteCommBuffLen)=0x7D;
    *(TxBuff+(OutputWriteP[CommNo]+2)%WriteCommBuffLen)=ChNo&1;
    *(TxBuff+(OutputWriteP[CommNo]+3)%WriteCommBuffLen)=0x83;
    *(TxBuff+(OutputWriteP[CommNo]+4)%WriteCommBuffLen)=(ChP+ChNum)->TczPara.ModemStatus;
    *(TxBuff+(OutputWriteP[CommNo]+5)%WriteCommBuffLen)=0x00;
    *(TxBuff+(OutputWriteP[CommNo]+6)%WriteCommBuffLen)=Lpc(TxBuff,OutputWriteP[CommNo]+2,4,WriteCommBuffLen);
    *(TxBuff+(OutputWriteP[CommNo]+7)%WriteCommBuffLen)=0x16;
    OutputWriteP[CommNo]=(OutputWriteP[CommNo]+8)%WriteCommBuffLen;
    GlobalUnlock(OutputCommMem[CommNo]);
    GlobalUnlock(hChannelParamMem);
    return 1;
}
BOOL DiReadSelf(BYTE ChNum)
{
    ChP = (CHANNELPARAM FAR *) GlobalLock(hChannelParamMem);
    if ((ChP+ChNum)->CHType!=2) {GlobalUnlock(hChannelParamMem);return 0;}
    BYTE CommNo,ChNo;
    GetSetCommNo=CommNo=(ChP+ChNum)->SIOOrd;
    GetSetChNo=ChNo=(ChP+ChNum)->ChNoInComm;

    if ((OutputReadP[CommNo]-OutputWriteP[CommNo]+WriteCommBuffLen)%WriteCommBuffLen<8) {GlobalUnlock(hChannelParamMem);return 0;}
    if (OutputCommMem[CommNo]==NULL) {GlobalUnlock(hChannelParamMem);return 0;}
    BYTE FAR *TxBuff=(BYTE FAR *)GlobalLock(OutputCommMem[CommNo]);
    *(TxBuff+(OutputWriteP[CommNo]+0)%WriteCommBuffLen)=0xBE;
    *(TxBuff+(OutputWriteP[CommNo]+1)%WriteCommBuffLen)=0x7D;
    *(TxBuff+(OutputWriteP[CommNo]+2)%WriteCommBuffLen)=ChNo&1;
    *(TxBuff+(OutputWriteP[CommNo]+3)%WriteCommBuffLen)=0x84;
    *(TxBuff+(OutputWriteP[CommNo]+4)%WriteCommBuffLen)=(ChP+ChNum)->TczPara.ModemStatus;
    *(TxBuff+(OutputWriteP[CommNo]+5)%WriteCommBuffLen)=0x00;
    *(TxBuff+(OutputWriteP[CommNo]+6)%WriteCommBuffLen)=Lpc(TxBuff,OutputWriteP[CommNo]+2,4,WriteCommBuffLen);
    *(TxBuff+(OutputWriteP[CommNo]+7)%WriteCommBuffLen)=0x16;
    OutputWriteP[CommNo]=(OutputWriteP[CommNo]+8)%WriteCommBuffLen;
    GlobalUnlock(OutputCommMem[CommNo]);
    GlobalUnlock(hChannelParamMem);
    return 1;
}
BOOL InitOneComm(BYTE CommNo)
{
char *baud[]={"150","300","600","1200","2400","4800","9600","19200","38400"};
char Buf[200];
int err;

    if (idComDev[CommNo]>=0) CloseComm(idComDev[CommNo]);
    if (idComDev[CommNo]!=-10) idComDev[CommNo]=-1;
    CommCount[CommNo]=0;
    if (InputCommMem[CommNo]) GlobalFree(InputCommMem[CommNo]);
    if (OutputCommMem[CommNo]) GlobalFree(OutputCommMem[CommNo]);

    InputCommMem[CommNo]=OutputCommMem[CommNo]=NULL;
    InputReadP[CommNo]=InputWriteP[CommNo]=OutputReadP[CommNo]=OutputWriteP[CommNo]=0;
    if (CommPara[CommNo-1].Used==0) return 0;
    wsprintf (Buf,"COM%d:",CommNo);
	err=idComDev[CommNo]= OpenComm(Buf, 512, 256);
    if (err==-10) CommPara[CommNo-1].Used=0; //如果该口已经被系统或其他程序占用则不用。
	if (err<0)
       {
        wsprintf((LPSTR)Buf,"打开串行口%d错，err=%d 错误代码=-2:已经打开,错误代码=-10：该口已经被系统占用！",CommNo,err);
        MessageBox( NULL, (LPSTR)Buf,(LPSTR)"串行通信提示", MB_OK) ;
        return FALSE;
       }
	lstrcat(Buf, baud[CommPara[CommNo-1].COMMBAUD]);
	lstrcat(Buf, ",n");
	lstrcat(Buf, ",8");
	lstrcat(Buf, ",1");
    err=BuildCommDCB(Buf, &dcb);
    lstrcat(Buf, " 创建DCB错!");
    if (err<0)
       {
        MessageBox( GetFocus(), (LPSTR)Buf,(LPSTR)"串行通信提示" ,MB_OK) ;
        return FALSE;
       }

    dcb.fDtrDisable=0;
    dcb.fRtsDisable=0;
    dcb.fOutxCtsFlow=0;
    dcb.fOutxDsrFlow=0;    //
    dcb.fRtsflow =0;
    dcb.fDtrflow = 0;
    dcb.fOutX=0;
    dcb.fInX=0;
    err=SetCommState((DCB far *)&dcb);
    if (err<0)                               
       {
        CloseComm(idComDev[CommNo]) ;
        idComDev[CommNo] = -1;
        wsprintf((LPSTR)Buf,"设置串行口状态错，err=%x", err);          
        MessageBox( GetFocus(), (LPSTR)Buf,(LPSTR)"串行通信提示", MB_OK);
        return FALSE;
       }
    FlushComm(idComDev[CommNo], 0);   // 清空发送队列
    FlushComm(idComDev[CommNo], 1);   // 清空接收队列
    InputCommMem[CommNo] = GlobalAlloc (GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, ReadCommBuffLen);
    OutputCommMem[CommNo] = GlobalAlloc (GMEM_NODISCARD|GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT, WriteCommBuffLen);
return 1;
}
//根据串行口号码计算出通道号
BYTE CalChNum(BYTE CommNo)
{
for (BYTE i=0;i<TotalChNum;i++)
    {
        if ((ChP+i)->SIOOrd==CommNo) return i;
    }
return 0xff;
}
12

comm.cpp - 源码说明

本页面展示了「这是一个在正实际应用当中运行的电力监控系统软件源代码」中的 comm.cpp 源码文件，采用 C++ 编程语言编写，共 682 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫开发者社区收录了大量与电力监控相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?