DSP28335 高速modbus代码实现

2023-05-16

程序特点

不使用while循环
速度尽可能快速
除去程序运行时间，没有多余等待时间
优化CRC校验方式

头文件modbus.h

#ifndef MODBUS_H
#define MODBUS_H

#define ModbusSlaveAddress 1

typedef enum {
    MB_FUNC_READ_COIL = 1,
    MB_FUNC_READ_INPUT,
    MB_FUNC_READ_HOLDINGREGISTERS,
    MB_FUNC_READ_INPUTREGISTERS,
    MB_FUNC_FORCE_COIL,
    MB_FUNC_WRITE_HOLDINGREGISTER,
    MB_FUNC_FORCE_NCOILS = 15,
    MB_FUNC_WRITE_NREGISTERS = 16
} ModbusFunctionCode;

typedef enum {
    MB_ERROR_ILLEGALFUNC = 1,
    MB_ERROR_ILLEGALADDR,
    MB_ERROR_ILLEGALDATA,
    MB_ERROR_SLVFAILURE,
    MB_ERROR_ACKNOWLEDGE,
    MB_ERROR_SLVBUSY,
    MB_ERROR_NEGACKNOWLEDGE,
    MB_ERROR_MEMPARITY,
    MB_ERROR_GATEWAYPATHUN
} ModbusError;

// State machine constants
typedef enum {
    MB_CREATE,
    MB_START,
    MB_TIMER_T35_WAIT,
    MB_IDLE,
    MB_RECEIVE,
    MB_PROCESS,
    MB_TRANSMIT,
    MB_DESTROY
} ModbusState;



typedef struct ModbusData ModbusData;
struct ModbusData {
    Uint16 slaveAddress;
    Uint16 functionCode;
    Uint32 contentIdx;
    Uint32 numofregisters;
    Uint16 content[20];
    Uint16 size;
    Uint16 crc;
};

void KD_Modbus_Init(void);

typedef struct ModbusCoilsMap ModbusCoilsMap;
struct ModbusCoilsMap{
    Uint16   dummy1;
    Uint16   dummy2;
    Uint16   dummy3;
    Uint16   dummy4;
    Uint16   dummy5;
    Uint16   dummy6;
    Uint16   dummy7;
    Uint16   dummy8;
    Uint16   dummy9;
    Uint16   dummy10;
    Uint16   dummy11;
    Uint16   dummy12;
    Uint16   dummy13;
    Uint16   dummy14;
    Uint16   dummy15;
    Uint16   dummy16;
    Uint16   dummy17;
    Uint16   dummy18;
    Uint16   dummy19;
    Uint16   dummy20;
    Uint16   dummy21;
    Uint16   dummy22;
    Uint16   dummy23;
    Uint16   dummy24;
    Uint16   dummy25;
    Uint16   dummy26;
    Uint16   dummy27;
    Uint16   dummy28;
    Uint16   dummy29;
    Uint16   dummy30;
    Uint16   dummy31;
    Uint16   dummy32;
    Uint16   dummy33;
    Uint16   dummy34;
    Uint16   dummy35;
    Uint16   dummy36;
    Uint16   dummy37;
    Uint16   dummy38;
    Uint16   dummy39;
    Uint16   dummy40;
};

typedef struct ModbusInputsMap ModbusInputsMap;
struct ModbusInputsMap{
    Uint16   dummy1;
    Uint16   dummy2;
    Uint16   dummy3;
    Uint16   dummy4;
    Uint16   dummy5;
    Uint16   dummy6;
    Uint16   dummy7;
    Uint16   dummy8;
    Uint16   dummy9;
    Uint16   dummy10;
    Uint16   dummy11;
    Uint16   dummy12;
    Uint16   dummy13;
    Uint16   dummy14;
    Uint16   dummy15;
    Uint16   dummy16;
    Uint16   dummy17;
    Uint16   dummy18;
    Uint16   dummy19;
    Uint16   dummy20;
    Uint16   dummy21;
    Uint16   dummy22;
    Uint16   dummy23;
    Uint16   dummy24;
    Uint16   dummy25;
    Uint16   dummy26;
    Uint16   dummy27;
    Uint16   dummy28;
    Uint16   dummy29;
    Uint16   dummy30;
    Uint16   dummy31;
    Uint16   dummy32;
    Uint16   dummy33;
    Uint16   dummy34;
    Uint16   dummy35;
    Uint16   dummy36;
    Uint16   dummy37;
    Uint16   dummy38;
    Uint16   dummy39;
    Uint16   dummy40;
};

typedef struct ModbusHoldingRegistersMap ModbusHoldingRegistersMap;
struct ModbusHoldingRegistersMap {
    Uint16  dummy1;
    Uint16  dummy2;
    Uint16  dummy3;
    Uint16  dummy4;
    Uint16  dummy5;
    Uint16  dummy6;
    Uint16  dummy7;
    Uint16  dummy8;
    Uint16  dummy9;
    Uint16  dummy10;
    Uint16  dummy11;
    Uint16  dummy12;
    Uint16  dummy13;
    Uint16  dummy14;
    Uint16  dummy15;
    Uint16  dummy16;
    Uint16  dummy17;
    Uint16  dummy18;
    Uint16  dummy19;
    Uint16  dummy20;
    Uint16  dummy21;
    Uint16  dummy22;
    Uint16  dummy23;
    Uint16  dummy24;
    Uint16  dummy25;
    Uint16  dummy26;
    Uint16  dummy27;
    Uint16  dummy28;
    Uint16  dummy29;
    Uint16  dummy30;
    Uint16  dummy31;
    Uint16  dummy32;
    Uint16  dummy33;
    Uint16  dummy34;
    Uint16  dummy35;
    Uint16  dummy36;
    Uint16  dummy37;
    Uint16  dummy38;
    Uint16  dummy39;
    Uint16  dummy40;
};

typedef struct ModbusInputRegistersMap ModbusInputRegistersMap;
struct ModbusInputRegistersMap {
    Uint16  dummy1;
    Uint16  dummy2;
    Uint16  dummy3;
    Uint16  dummy4;
    Uint16  dummy5;
    Uint16  dummy6;
    Uint16  dummy7;
    Uint16  dummy8;
    Uint16  dummy9;
    Uint16  dummy10;
    Uint16  dummy11;
    Uint16  dummy12;
    Uint16  dummy13;
    Uint16  dummy14;
    Uint16  dummy15;
    Uint16  dummy16;
    Uint16  dummy17;
    Uint16  dummy18;
    Uint16  dummy19;
    Uint16  dummy20;
    Uint16  dummy21;
    Uint16  dummy22;
    Uint16  dummy23;
    Uint16  dummy24;
    Uint16  dummy25;
    Uint16  dummy26;
    Uint16  dummy27;
    Uint16  dummy28;
    Uint16  dummy29;
    Uint16  dummy30;
    Uint16  dummy31;
    Uint16  dummy32;
    Uint16  dummy33;
    Uint16  dummy34;
    Uint16  dummy35;
    Uint16  dummy36;
    Uint16  dummy37;
    Uint16  dummy38;
    Uint16  dummy39;
    Uint16  dummy40;
};

typedef struct ModbusSlaveStruc{
    ModbusState state;
    Uint16 rdata[30];
    Uint16 sdata[100];
    Uint16 recvlen;
    Uint16 sendlen;
    ModbusCoilsMap coils,*pcoils;
    ModbusInputsMap inputs,*pinputs;
    ModbusHoldingRegistersMap holdingRegisters,*pholdingRegisters;
    ModbusInputRegistersMap inputRegisters,*pinputRegisters;
}MBSLSTRU;

#endif

源文件modbus.c

/*********************************************************
 * 处理一个数据需要8个us，所以尽可能一次多访问几个数据，可以一次把40个寄存器读完
 * 发送命令计算校验码时，前后都不能有多余字符，不然校验会出错
 * 波特率460800，暂时不修改
 * ***************************************************************/
#include <DSP2833x_Device.h>
#include <DSP2833x_Examples.h>
#include <Modbus.h>
#include <string.h>  //用于清零数组

MBSLSTRU public_struc_modbus;

void receieve_handler(MBSLSTRU *pModbusSlave);
//void Scic_xmit(int a);
Uint16 CRC16 (Uint16 *nData, Uint16 wLength);

#define bufferdepth 0x10
//CycleQueue ScicRecvMsgQueue;
//struct ScicRecvMsgQueueStruc ScicRecvMsgBox[ScicRecvMsgLen], *pScicRecvMsgQueueStruc;


__interrupt void scicTxFifoIsr(void)
{
    Uint16 i, Temp;

    if((public_struc_modbus.sendlen&0xff)>bufferdepth)
    {
        Temp = bufferdepth;
        ScicRegs.SCIFFTX.bit.TXFFIL = 0;

        for(i=0; i< Temp; i++)
        {
            ScicRegs.SCITXBUF = public_struc_modbus.sdata[i + bufferdepth*(public_struc_modbus.sendlen>>12)];
        }
        public_struc_modbus.sendlen = public_struc_modbus.sendlen - bufferdepth + 0x1000;
    }
    else
    {
        Temp = (public_struc_modbus.sendlen&0xff);
        if((public_struc_modbus.sendlen&0xff)>0)
        {
            ScicRegs.SCIFFTX.bit.TXFFIL = 0;

            for(i=0; i< Temp; i++)
            {
                ScicRegs.SCITXBUF = public_struc_modbus.sdata[i + bufferdepth*(public_struc_modbus.sendlen>>12)];
            }
            public_struc_modbus.sendlen = 0;
        }
        else
        {
            if(public_struc_modbus.sendlen==0)
            {
                ScicRegs.SCIFFTX.bit.TXFFIENA = 0;
            }
        }
    }

    ScicRegs.SCIFFTX.bit.TXFFINTCLR=1;  // Clear Interrupt flag
    PieCtrlRegs.PIEACK.bit.ACK8=1;
}


__interrupt void scicRxFifoIsr(void)
{
    Uint16 i;
    if(ScicRegs.SCIFFRX.bit.RXFFIL != 1)
    {
        if(public_struc_modbus.rdata[1]==0)
        {
            for(i=1;i<8;i++)
            {
                public_struc_modbus.rdata[i]=ScicRegs.SCIRXBUF.all;  // Read data
            }
        }
        if((public_struc_modbus.rdata[1]==15)||(public_struc_modbus.rdata[1]==16))
        {
            if(public_struc_modbus.recvlen == 0)
            {
                public_struc_modbus.recvlen = public_struc_modbus.rdata[6] + 9 + 0x1000;
                ScicRegs.SCIFFRX.bit.RXFFIL = 8;
                i = public_struc_modbus.recvlen&0xff - ((public_struc_modbus.recvlen>>12)*8);
                if(i>8)
                {ScicRegs.SCIFFRX.bit.RXFFIL = 8;}
                else
                {ScicRegs.SCIFFRX.bit.RXFFIL = i;}
            }
            else
            {

                if((public_struc_modbus.recvlen>>12)<((public_struc_modbus.recvlen&0xFF)/8))
                {
                    for(i=0;i<8;i++)
                    {
                        public_struc_modbus.rdata[i+(public_struc_modbus.recvlen>>12)*8]=ScicRegs.SCIRXBUF.all;  // Read data
                    }
                    public_struc_modbus.recvlen = public_struc_modbus.recvlen + 0x1000;
                    i = public_struc_modbus.recvlen&0xff - ((public_struc_modbus.recvlen>>12)*8);
                    if(i>8)
                    {ScicRegs.SCIFFRX.bit.RXFFIL = 8;}
                    else
                    {ScicRegs.SCIFFRX.bit.RXFFIL = i;}
                }
                else
                {
                    for(i=0;i<((public_struc_modbus.recvlen&0xFF)%8);i++)
                    {
                        public_struc_modbus.rdata[i+(public_struc_modbus.recvlen>>12)*8]=ScicRegs.SCIRXBUF.all;  // Read data
                    }
                    if((public_struc_modbus.recvlen&0xFF) <= (i+(public_struc_modbus.recvlen>>12)*8))
                    {
                        receieve_handler(&public_struc_modbus);
                        public_struc_modbus.rdata[1] = 0;
                        ScicRegs.SCIFFRX.bit.RXFFIL = 1;
                        public_struc_modbus.recvlen = 0;
                    }
                }
            }
        }
        else
        {
            public_struc_modbus.recvlen = 8;

            if((public_struc_modbus.rdata[1]>=1)&&(public_struc_modbus.rdata[1]<=6))
            {
                receieve_handler(&public_struc_modbus);
                public_struc_modbus.rdata[1] = 0;
                public_struc_modbus.recvlen = 0;
                ScicRegs.SCIFFRX.bit.RXFFIL = 1;
            }
            else
            {
                    receieve_handler(&public_struc_modbus);
                    public_struc_modbus.rdata[1] = 0;
                    ScicRegs.SCIFFRX.bit.RXFFIL = 1;
            }
        }
    }
    else
    {
        public_struc_modbus.rdata[0]=ScicRegs.SCIRXBUF.all;
        if(public_struc_modbus.rdata[0] == ModbusSlaveAddress)
        {ScicRegs.SCIFFRX.bit.RXFFIL = 7;}
        else
        {ScicRegs.SCIFFRX.bit.RXFFIL = 1;}
    }


    ScicRegs.SCIFFRX.bit.RXFFOVRCLR=1;  // Clear Overflow flag
    ScicRegs.SCIFFRX.bit.RXFFINTCLR=1;  // Clear Interrupt flag

    PieCtrlRegs.PIEACK.bit.ACK8=1;
}

void KD_Modbus_Init(void)
{
    InitScicGpio();

    InitSci();

    EALLOW;
    PieVectTable.SCIRXINTC = &scicRxFifoIsr;
    PieVectTable.SCITXINTC = &scicTxFifoIsr;
    EDIS;

    PieCtrlRegs.PIECTRL.bit.ENPIE = 1;
    PieCtrlRegs.PIEIER8.bit.INTx5=1;     // PIE Group 9, int1
    PieCtrlRegs.PIEIER8.bit.INTx6=1;     // PIE Group 9, INT2
    IER|=M_INT8; // Enable CPU INT

    public_struc_modbus.recvlen = 0;
    public_struc_modbus.sendlen = 0;

    Uint16 i, *pcoils_sub, *pinputs_sub, *pholdingRegisters_sub, *pinputRegisters_sub;
    public_struc_modbus.pcoils = &public_struc_modbus.coils;
    public_struc_modbus.pinputs = &public_struc_modbus.inputs;
    public_struc_modbus.pholdingRegisters = &public_struc_modbus.holdingRegisters;
    public_struc_modbus.pinputRegisters = &public_struc_modbus.inputRegisters;

    pcoils_sub =(Uint16 *) public_struc_modbus.pcoils;
    pinputs_sub =(Uint16 *) public_struc_modbus.pinputs;
    pholdingRegisters_sub =(Uint16 *) public_struc_modbus.pholdingRegisters;
    pinputRegisters_sub =(Uint16 *) public_struc_modbus.pinputRegisters;

    for(i=0;i<sizeof(public_struc_modbus.coils);i++)
    {(i%2==1)?(*(pcoils_sub+i)=1):(*(pcoils_sub+i)=0);}
    for(i=0;i<sizeof(public_struc_modbus.inputs);i++)
    {(i%2==0)?(*(pinputs_sub+i)=1):(*(pinputs_sub+i)=0);}
    for(i=0;i<sizeof(public_struc_modbus.holdingRegisters);i++)
    {*(pholdingRegisters_sub+i)=i+1;}
    for(i=0;i<sizeof(public_struc_modbus.inputRegisters);i++)
    {*(pinputRegisters_sub+i)=i+1;}

    memset(public_struc_modbus.rdata,0,sizeof(public_struc_modbus.rdata));
}

void receieve_handler(MBSLSTRU *pModbusSlave)
{
    Uint16 i, lentemp = public_struc_modbus.recvlen & 0xff;
    ModbusData pTempData;
    Uint16 *pcoils_sub, *pinputs_sub, *pholdingRegisters_sub, *pinputRegisters_sub;
//    struct ScicRecvMsgQueueStruc KD_ScicRecvMsg;

    pcoils_sub =(Uint16 *) pModbusSlave->pcoils;
    pinputs_sub =(Uint16 *) pModbusSlave->pinputs;
    pholdingRegisters_sub =(Uint16 *) pModbusSlave->pholdingRegisters;
    pinputRegisters_sub =(Uint16 *) pModbusSlave->pinputRegisters;

    memset(pModbusSlave->sdata,0,sizeof(pModbusSlave->sdata));

    pTempData.crc = ((pModbusSlave->rdata[lentemp-2])<<8)+pModbusSlave->rdata[lentemp-1];

    pModbusSlave->sdata[0] = pModbusSlave->rdata[0];

    if(pModbusSlave->rdata[0]==ModbusSlaveAddress)
    {//从地址检查
        pModbusSlave->sdata[1] = pModbusSlave->rdata[1];

        if(CRC16(pModbusSlave->rdata, lentemp-2) == pTempData.crc)
        {//校验CRC
            pTempData.contentIdx = (pModbusSlave->rdata[2]<<8)+pModbusSlave->rdata[3];
            pTempData.numofregisters = (pModbusSlave->rdata[4]<<8)+pModbusSlave->rdata[5];//这里不表示寄存器数目，表示线圈的状态

            if((pTempData.contentIdx+pTempData.numofregisters)>40)
            {         //数值超限判定
                pModbusSlave->sdata[1]|= 0x80;
                pModbusSlave->sdata[2]|= 0x03;
                i=CRC16(pModbusSlave->sdata, 3);
                pModbusSlave->sdata[3]= (i>>8)&0xff;
                pModbusSlave->sdata[4]= i&0xff;
                pModbusSlave->sendlen=5;
                ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;
                ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
            }
            else
            {
                switch(pModbusSlave->rdata[1])
                {
                    case MB_FUNC_READ_COIL:
                        pModbusSlave->sdata[2] = (pTempData.numofregisters+7)/8;   //向上取整
                        for(i=0;i<pTempData.numofregisters;i++)
                        {
                            pModbusSlave->sdata[3+(i/8)] |= (*(pcoils_sub+i+pTempData.contentIdx) << (i%8));
                        }
                        i=CRC16(pModbusSlave->sdata, pModbusSlave->sdata[2]+3);
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+1]=(i>>8)&0xff;
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+2]=i&0xff;
                        pModbusSlave->sendlen= pModbusSlave->sendlen + 5 + pModbusSlave->sdata[2];
                        if(pModbusSlave->sendlen > bufferdepth)
                        {ScicRegs.SCIFFTX.bit.TXFFIL = bufferdepth;}
                        else
                        {ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;}
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    case MB_FUNC_READ_INPUT:
                        pModbusSlave->sdata[2] = (pTempData.numofregisters+7)/8;   //向上取整
                        for(i=0;i<pTempData.numofregisters;i++)
                        {
                            pModbusSlave->sdata[3+(i/8)]|=*(pinputs_sub+i+pTempData.contentIdx) << (i%8);
                        }
                        i=CRC16(pModbusSlave->sdata, pModbusSlave->sdata[2]+3);
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+1]=(i>>8)&0xff;
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+2]=i&0xff;
                        pModbusSlave->sendlen= pModbusSlave->sendlen + 5 + pModbusSlave->sdata[2];
                        if(pModbusSlave->sendlen > bufferdepth)
                        {ScicRegs.SCIFFTX.bit.TXFFIL = bufferdepth;}
                        else
                        {ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;}
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    case MB_FUNC_READ_HOLDINGREGISTERS:
                        pModbusSlave->sdata[2] = pTempData.numofregisters*2;   //向上取整
                        for(i=0;i<(pTempData.numofregisters);i++)
                        {
                            pModbusSlave->sdata[3+i*2+1]=*(pholdingRegisters_sub+i+pTempData.contentIdx) ;
                            pModbusSlave->sdata[3+i*2+1] = (pModbusSlave->sdata[3+i*2+1]) & 0xff;
                            pModbusSlave->sdata[3+i*2]=*(pholdingRegisters_sub+i+pTempData.contentIdx) ;
                            pModbusSlave->sdata[3+i*2]=(pModbusSlave->sdata[3+i*2])>>8;
                        }
                        i=CRC16(pModbusSlave->sdata, pModbusSlave->sdata[2]+3);
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+1]=(i>>8)&0xff;
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+2]=i&0xff;
                        pModbusSlave->sendlen= pModbusSlave->sendlen + 5 + pModbusSlave->sdata[2];
                        if(pModbusSlave->sendlen > bufferdepth)
                        {ScicRegs.SCIFFTX.bit.TXFFIL = bufferdepth;}
                        else
                        {ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;}
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    case MB_FUNC_READ_INPUTREGISTERS:
                        pModbusSlave->sdata[2] = pTempData.numofregisters*2;   //向上取整
                        for(i=0;i<(pTempData.numofregisters);i++)
                        {
                            pModbusSlave->sdata[3+i*2+1]=*(pinputRegisters_sub+i+pTempData.contentIdx) ;
                            pModbusSlave->sdata[3+i*2+1] = (pModbusSlave->sdata[3+i*2+1]) & 0xff;
                            pModbusSlave->sdata[3+i*2]=*(pinputRegisters_sub+i+pTempData.contentIdx) ;
                            pModbusSlave->sdata[3+i*2]=(pModbusSlave->sdata[3+i*2])>>8;
                        }
                        i=CRC16(pModbusSlave->sdata, pModbusSlave->sdata[2]+3);
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+1]=(i>>8)&0xff;
                        pModbusSlave->sdata[2+pModbusSlave->sdata[2]+2]=i&0xff;
                        pModbusSlave->sendlen= pModbusSlave->sendlen + 5 + pModbusSlave->sdata[2];
                        if(pModbusSlave->sendlen > bufferdepth)
                        {ScicRegs.SCIFFTX.bit.TXFFIL = bufferdepth;}
                        else
                        {ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;}
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    case MB_FUNC_FORCE_COIL:
                        for(i=2;i<8;i++)
                        {
                            pModbusSlave->sdata[i] = pModbusSlave->rdata[i];
                        }
                        if(pTempData.numofregisters==0xFF00)
                        {
                            *(pcoils_sub+pTempData.contentIdx)=1;
                            pModbusSlave->sendlen=8;
                        }
                        else
                        {
                            if(pTempData.numofregisters==0x0000)
                            {
                                *(pcoils_sub+pTempData.contentIdx)=0;
                                pModbusSlave->sendlen=8;
                            }
                            else//命令错误
                            {
                                pModbusSlave->sdata[1]= 0x85;
                                pModbusSlave->sdata[2]= 0x03;
                                i=CRC16(pModbusSlave->sdata, 3);
                                pModbusSlave->sdata[3]= (i>>8)&0xff;
                                pModbusSlave->sdata[4]= i&0xff;
                                pModbusSlave->sendlen=5;
                            }
                        }

                        ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    case MB_FUNC_WRITE_HOLDINGREGISTER:
                        for(i=2;i<8;i++)
                        {
                            pModbusSlave->sdata[i] = pModbusSlave->rdata[i];
                        }

                        *(pholdingRegisters_sub+pTempData.contentIdx)=pTempData.numofregisters;
                        pModbusSlave->sendlen=8;

                        ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    case MB_FUNC_FORCE_NCOILS:
                        for(i=0;i<pTempData.numofregisters;i++)
                        {
                            *(pcoils_sub+i+pTempData.contentIdx) = ((pModbusSlave->rdata[i/8+7])>>(i%8))&0x01;
                        }
                        for(i=2;i<7;i++)
                        {
                            pModbusSlave->sdata[i] = pModbusSlave->rdata[i];
                        }

                        i=CRC16(pModbusSlave->sdata, 7);
                        pModbusSlave->sdata[7]=(i>>8)&0xff;
                        pModbusSlave->sdata[8]=i&0xff;
                        pModbusSlave->sendlen=9;
                        ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    case MB_FUNC_WRITE_NREGISTERS:
                        for(i=0;i<pTempData.numofregisters;i++)
                        {
                            *(pholdingRegisters_sub+i+pTempData.contentIdx) =(Uint16)(pModbusSlave->rdata[i*2+7]<<8) + (pModbusSlave->rdata[i*2+8]&0xFF);
                        }
                        for(i=2;i<6;i++)
                        {
                            pModbusSlave->sdata[i] = pModbusSlave->rdata[i];
                        }

                        i=CRC16(pModbusSlave->sdata, 6);
                        pModbusSlave->sdata[6]=(i>>8)&0xff;
                        pModbusSlave->sdata[7]=i&0xff;
                        pModbusSlave->sendlen=8;
                        ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                    default:
                        pModbusSlave->sdata[2]= 0x03;
                        i=CRC16(pModbusSlave->sdata, 3);
                        pModbusSlave->sdata[3]= (i>>8)&0xff;
                        pModbusSlave->sdata[4]= i&0xff;
                        pModbusSlave->sendlen=5;
                        ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;
                        ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
                        break;
                }
            }
        }
        else//校验码错误
        {
            pModbusSlave->sdata[1]|= 0x80;
            pModbusSlave->sdata[2]|= 0x03;
            i=CRC16(pModbusSlave->sdata, 3);
            pModbusSlave->sdata[3]= (i>>8)&0xff;
            pModbusSlave->sdata[4]= i&0xff;
            pModbusSlave->sendlen=5;
            ScicRegs.SCIFFTX.bit.TXFFIL = pModbusSlave->sendlen;
            ScicRegs.SCIFFTX.bit.TXFFIENA = 1;
        }
    }
    else//地址错误不处理
    {     }
}

//void Scic_xmit(int a)
//{
//    while(ScicRegs.SCICTL2.bit.TXRDY!=1){}
//    ScicRegs.SCITXBUF = a;
//}


Uint16 CRC16 (Uint16 *nData, Uint16 wLength)
{
    static const Uint16 wCRCTable[] = {
       0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241,
       0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440,
       0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40,
       0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841,
       0XD801, 0X18C0, 0X1980, 0XD941, 0X1B00, 0XDBC1, 0XDA81, 0X1A40,
       0X1E00, 0XDEC1, 0XDF81, 0X1F40, 0XDD01, 0X1DC0, 0X1C80, 0XDC41,
       0X1400, 0XD4C1, 0XD581, 0X1540, 0XD701, 0X17C0, 0X1680, 0XD641,
       0XD201, 0X12C0, 0X1380, 0XD341, 0X1100, 0XD1C1, 0XD081, 0X1040,
       0XF001, 0X30C0, 0X3180, 0XF141, 0X3300, 0XF3C1, 0XF281, 0X3240,
       0X3600, 0XF6C1, 0XF781, 0X3740, 0XF501, 0X35C0, 0X3480, 0XF441,
       0X3C00, 0XFCC1, 0XFD81, 0X3D40, 0XFF01, 0X3FC0, 0X3E80, 0XFE41,
       0XFA01, 0X3AC0, 0X3B80, 0XFB41, 0X3900, 0XF9C1, 0XF881, 0X3840,
       0X2800, 0XE8C1, 0XE981, 0X2940, 0XEB01, 0X2BC0, 0X2A80, 0XEA41,
       0XEE01, 0X2EC0, 0X2F80, 0XEF41, 0X2D00, 0XEDC1, 0XEC81, 0X2C40,
       0XE401, 0X24C0, 0X2580, 0XE541, 0X2700, 0XE7C1, 0XE681, 0X2640,
       0X2200, 0XE2C1, 0XE381, 0X2340, 0XE101, 0X21C0, 0X2080, 0XE041,
       0XA001, 0X60C0, 0X6180, 0XA141, 0X6300, 0XA3C1, 0XA281, 0X6240,
       0X6600, 0XA6C1, 0XA781, 0X6740, 0XA501, 0X65C0, 0X6480, 0XA441,
       0X6C00, 0XACC1, 0XAD81, 0X6D40, 0XAF01, 0X6FC0, 0X6E80, 0XAE41,
       0XAA01, 0X6AC0, 0X6B80, 0XAB41, 0X6900, 0XA9C1, 0XA881, 0X6840,
       0X7800, 0XB8C1, 0XB981, 0X7940, 0XBB01, 0X7BC0, 0X7A80, 0XBA41,
       0XBE01, 0X7EC0, 0X7F80, 0XBF41, 0X7D00, 0XBDC1, 0XBC81, 0X7C40,
       0XB401, 0X74C0, 0X7580, 0XB541, 0X7700, 0XB7C1, 0XB681, 0X7640,
       0X7200, 0XB2C1, 0XB381, 0X7340, 0XB101, 0X71C0, 0X7080, 0XB041,
       0X5000, 0X90C1, 0X9181, 0X5140, 0X9301, 0X53C0, 0X5280, 0X9241,
       0X9601, 0X56C0, 0X5780, 0X9741, 0X5500, 0X95C1, 0X9481, 0X5440,
       0X9C01, 0X5CC0, 0X5D80, 0X9D41, 0X5F00, 0X9FC1, 0X9E81, 0X5E40,
       0X5A00, 0X9AC1, 0X9B81, 0X5B40, 0X9901, 0X59C0, 0X5880, 0X9841,
       0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40,
       0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41,
       0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641,
       0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040 };

    Uint16 nTemp;
    Uint16 wCRCWord = 0xFFFF;

    while (wLength--)
    {
        nTemp = (*nData++ ^ wCRCWord)&0xff;
        wCRCWord >>= 8;
        wCRCWord  ^= wCRCTable[nTemp];
    }
    wCRCWord = (Uint16) ((wCRCWord<<8)+(wCRCWord>>8));
    return wCRCWord;
} // End: CRC16

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

DSP28335

Modbus

代码实现

DSP28335 高速modbus代码实现的相关文章

串口通信之（一）获取传感器数据（modbus rtu master）

一天领导拿了几个传感器设备丢给我 xff0c 给我把这些数据取到我一看 xff0c 好家伙这是要搞硬件了啊那就搞他丫的可是 xff0c 怎么搞是个问题我是一头雾水还好 xff0c 和传感器丢给我的 xff0c 还有传感器厂家一起
【STM32】RS485 Modbus协议采集传感器数据

源码链接 xff1a Modbus传感器采集协议一硬件 1 传感器 xff1a 为液压传感器 xff0c 12vDC xff0c RS485数据输出 xff0c 采用Modbus协议通信 2 电路 xff1a 根据传感器属性 xff0c
DSP28335使用FIFO的串口中断总结

一串行通信与并行通信 DSP控制器间 xff0c DSP控制器与外部设备间交换信息 xff0c 通信 xff0c 可采取的通信方式主要两大类1 串行通信 2 并行通信并行通信一般包括多条数据线多条控制线和状态线 xff0c 传输速度快
Modbus-RTU通讯协议中CRC校验码的计算步骤

在CRC计算时只用8个数据位 xff0c 起始位及停止位 xff0c 如有奇偶校验位也包括奇偶校验位 xff0c 都不参与CRC计算 CRC计算方法是 xff1a 1 预置1个16位的寄存器为十六进制FFFF xff08 全1 xff09
Modbus 协议

1 主站 xff1a 可以进行读写操作从站 xff1a 只能被动响应主站操作 2 一个 Modbus 网络只有一个主站 xff0c 可以多个从站 xff08 主站不用连在两端 xff09 485 通讯 1 接线最多 254 个站 xff
DSP28335笔记--SCI篇

采用FIFO来实现数据的发送与接收 xff0c 一般就是指采用FIFO中断在标准SCI模式下通过中断方式来接收或者发送数据可以发现 xff0c 每接收或者发送一个字符就要进一次中断 xff0c 如果发送的字符比较多的话 xff0c 很明显
DSP28335 SCI FIFO深度设置

SCI工作在FIFO模式下一般是因为所传输的信息并不是以一个字节为单位 xff0c 而是以多个字节组成的一个包为单位的如果一包数据包括10个字节 xff0c 可以设置FIFO接收中断为10个字节时产生中断设置以后 xff0c 每接收到1
Modbus学习笔记

Modbus通信协议 1 Modbus简介来自维基百科 Modbus是一种串行通信协议是Modicon于1979年为使用可编程逻辑控制器 PLC 而发表的 Modbus是工业领域通信协议的业界标准并且现在是工业电子设备之间相当常用的
Modbus CRC和LRC算法研究及代码实现

一 CRC 循环冗余校验 1 CRC16实现流程 XOR 异或 N 字节的信息位 POLY CRC16 多项式计算 1010 0000 0000 0001 生成多项式 1 x2 x15 x16 在CRC16中发送的第一个字节位低字节 2
QtModbus Serial 简单示例

来自QQ群 Linux 技术分享 311078264 打开链接加入QQ群 https jq qq com wv 1027 k 5Gr3bAx 此文档由elikang整理为了文章简单直接许多细节未能在文章中体现如有疑问请进群讨论 Qt
modbus之crc16计算代码

这边提供两种方式第1种是查表法方式速度会快一点但是需要多占用一些空间第二种是纯计算方式速度相对第一种会慢一点但是比较省空间代码如下 static const uint16 t crc table 0X0000 0XC0C1 0
Modbus常用功能码协议详解

Modbus常用功能码协议详解 01H 读线圈状态 1 描述读从机线圈寄存器位操作可读单个或者多个 2 发送指令假设从机地址位0x01 寄存器开始地址0x0023 寄存器结束抵制0x0038 总共读取21个线圈协议图如下 3 响应
【Modbus】 RTU CRC校验码计算方法

Modbus是美国Modicon公司即现在的Schneider Electric公司于1979年开发的一种通信协议其目的是采用一根双绞线实现多个设备之间的通信 Modbus 协议采用问答式的通信方式具有简单硬件便宜通用性强使用
modbus读取保持寄存器实例

读取108 110的实例一共读取3个寄存器请求 03 00 6B 00 03 03 功能码表示读取保存寄存器 006B 十六进制表示107 从107开始往后读取 0003 十六进制表示读取3个寄存器响应 03 06 02 2B 00
STM32F429 HAL库移植FreeModbus_RTU详细步骤

STM32F429 HAL库移FreeModbus RTU详细步骤开发环境说明完整工程文件下载地址移植前提修改 RS485 c 文件修改 portserial c 文件修改 porttimer c 文件修改 stm32f4xx
在Python中计算modbus的CRC16

首先抱歉我是初学者我在 modbus 上得到以下字节序列 01 04 08 00 00 00 09 00 00 00 00f8 0c 该字节序列上粗体的 CRC 是正确的但是要检查创建 CRC 我必须遵循设备规范其中规定错误
需要 modbus Java 库 [关闭]

Closed 此问题正在寻求书籍工具软件库等的推荐不满足堆栈溢出指南 help closed questions 目前不接受答案我需要带有源代码的简单 modbus Java 库我在谷歌上找到了但有 jar 文件并且没有强大的
带 Spring Boot 项目的 Modbus 脉冲线圈

必须实施呼叫数字IO with Modbus协议 on 春季启动项目构建者Maven 它应该是在身体上有一定持续时间的脉冲呼叫例如 5 秒等以下是规范中的一个片段关于响应和错误的更多信息看来这个呼叫应用程序应该表现得像一个大师在这
Modbus 错误：[无效消息] 收到的消息不完整，预计至少 2 个字节（收到 0 个字节）

Problem pymodbus 主站客户端可以向从站服务器发送请求从属服务器准备好返回的东西并等待主控客户端来接收它们尽管服务器从站已准备就绪但主站客户端仅返回错误 Modbus 错误输入输出 Modbus 错误
如何在 iPhone 应用程序中与 Modbus 设备通信？

我希望能够开发一个可以与 Modbus 设备通信的 iPhone 应用程序但我不知道如何继续有没有人有这方面的经验或者是否有用于此目的的现有图书馆您首先需要知道如何在您的 iPhone 上创建一个简单的 TCP 客户端以及如何在您

随机推荐

png图片自动转ttf字体（使用python实现）

这里写目录标题一任务概述二实现2 1 ocr识别2 1 1 安装环境2 1 2 实现脚本 2 2 图形文字精确提取2 3 png转svg2 4 svg转ttf 一任务概述任务要求 xff1a 需要将上述生僻字png图片批量自动转成
一文掌握基于深度学习的人脸表情识别开发（基于PaddlePaddle）

目录一概述1 1 表情分类1 2 表情识别方法1 2 1 人工特征方法1 2 2 神经网络方法 1 3 本文实现二环境准备2 1 安装PaddlePaddle2 2 安装PaddleClas 三人脸检测3 1 概述3 2 下载静态
基于深度学习的人脸识别闸机开发（基于飞桨PaddlePaddle）

目录一概述1 1 人脸识别背景1 2 实现1 2 1 算法说明1 2 2 环境设置1 2 3 实现思路二示例脚本2 1 安装PaddlePaddle和PLSC2 2 下载人脸检测模型blazeface2 3 下载人脸识别模型arcf
基于深度学习的多任务人脸属性分析（基于飞桨PaddlePaddle）

目录一概述1 1 多任务人脸属性分析1 2 本文任务二环境配置2 1 安装PaddlePaddle2 2 安装PaddleClas 三算法模型开发3 1 算法原理3 2 数据集准备3 2 1 使用labelme标注原始数据3 2
一文掌握Ubuntu20.04深度学习环境搭建（显卡驱动、CUDA、CUDNN、NCCL、Pytorch、PaddlePaddle）

目录一 Ubuntu系统安装1 1 制作U盘镜像并安装1 2 安装make g 43 43 cmake1 3 安装中文输入法1 4 安装VS Code 二深度学习环境安装2 1 切换Python版本2 2 安装英伟达显卡驱动2 3 明确
pytorch和paddle的存储模型变量state_dict命名规则分析

目录一 Pytorch存储模型变量命名分析二 PaddlePaddle存储模型变量命名分析三 Pytorch和Paddle相互转化一 Pytorch存储模型变量命名分析在pytorch中 xff0c 存储变量的名称就在def init
PySide6精简教程

目录一 PySide6概述二安装PySide6三设计界面四响应UI操作五打包部署一 PySide6概述近几年 xff0c 受益于人工智能的崛起 xff0c Python语言几乎以压倒性优势在众多编程语言中异军突起 xff0c
flask数字图像处理系统开发全流程记录（基于OpenCV）

目录一环境安装1 1 安装虚拟环境1 2 安装Flask 二搭建flask项目框架2 1 创建一个简单项目2 2 渲染html页面2 3 使用Bootstrap美化页面2 4 前后端逻辑交互2 4 1 前端实现2 4 2 后端实现三
github代码拉取和上传出现“failed: The TLS connection was non-properly terminated”错误解决方案

在使用VS Code上传代码到github时出现下面的错误 xff1a gnutls handshake span class token punctuation span span class token punctuation span
高翔博士：视觉SLAM十四讲笔记（nX）

0 为什么标题的编号是 xff08 nX xff09 因为是在学习到第7章的时候 xff0c 被有关G2O的安装和编译不通过给搞疯了 xff0c 要成魔了 xff0c 才想起了应该把踩过的坑记录下来 xff0c 以供日后学习 xff0c 也
GetAsyncKeyState函数中按键的信息

转自MSDN http msdn microsoft com en us library windows desktop dd375731 v 61 vs 85 aspx 用法 if GetAsyncKeyState 0x51 amp 0x
在Jetson Nano上编译FastDeploy

1 C 43 43 库的编译 span class token function git span clone https github com PaddlePaddle FastDeploy git span class token bu
一文掌握FastDeploy Serving服务化部署(打造线上证件照制作系统，含完整代码)

目录一概述1 1 服务化部署1 2 FastDeploy简介二搭建线上证件照制作系统2 1 准备环境2 1 1 安装Docker2 1 2 安装NVIDIA Container Toolkit2 1 3 获取FastDeploy S
部署散记1（增强）

拉取modelscope镜像 span class token function sudo span span class token function docker span pull registry cn hangzhou aliyu
图形化深度学习开发平台PaddleStudio（代码开源）

目录一 PaddleStudio概述二环境准备2 1 安装PaddlePaddle2 2 安装依赖库三基本使用介绍3 1 启动3 2 快速体验3 2 1 下载示例项目3 2 2 训练3 2 3 评估3 2 4 测试3 2 5 静态图
一款免费的人像修图工具（笨擦擦）

推荐一个我们自己开发的免费人像修图工具 xff1a 笨擦擦使用这个工具可以免费抠图美颜证件照制作我们是一群因为兴趣聚在一起的二哈程序员 xff0c 我们没资金没大佬没资质 xff0c 但就是喜欢做一些有意思的事笨擦擦是我
利用Python生成和识读二维码（QR Code）和微二维码（Micro QR Code）

目录一环境准备二二维码 xff08 QR Code xff09 生成和读取2 1 生成二维码2 2 读取二维码三微二维码 xff08 Micro QR Code xff09 生成和读取3 1 生成微二维码3 2 读取微二维码之前
贴图问题，opengl，linux，windows，消除锯齿，摩尔纹，yuv 还是 rgb

1 消除锯齿和摩尔纹 windows下使用d3d是很方便的 xff0c 基本不用设置很多东西 xff0c 就可以做到 xff0c 所以windows上最好使用d3d 但是linux上有所不同摩尔条纹是两条线或两个物体之间以恒定的角度和频率
QT基础(五)----QPainter高级功能

一场景和窗口头文件MyWidget h ifndef MYWIDGET H define MYWIDGET H include lt QWidget gt include lt QGraphicsScene gt 场景 include
DSP28335 高速modbus代码实现

程序特点不使用while循环速度尽可能快速除去程序运行时间 xff0c 没有多余等待时间优化CRC校验方式头文件modbus h span class token macro property span class token dire

DSP28335 高速modbus代码实现

DSP28335 高速modbus代码实现 的相关文章

随机推荐

热门标签

DSP28335 高速modbus代码实现的相关文章