求助，已经能实现DSP和触摸屏的单地址通讯，怎么才能实现触摸屏上多地址和DSP的通讯

leroi · 发表于 2016-5-21 10:14:06

/*****************************************************************************
1.实验过程：(1)通过串口助手向dsp发送一个基于MODBUS协议的功能码如01 01 00 00 00 01 FD CA （位读bit）
;串口助手接收到返回所要读取地址的内容;(2)通过MODBUS调试工具ModScan32向dsp发送信息读取某个线圈状态,dsp
收到信息后返回相应线圈的状态;(3)增加了功能03H,可读取单个或多个保持寄存器的值;(4)增加了功能05H可写单个线圈;
(5)增加了功能06H可写单个寄存器;

2.使用资源：
①tms320f28335 SCIB模块：
（芯片18脚第三功能SCITXDB即 SCIB 的TXD
芯片19脚第三功能SCIRXDB即 SCIB 的RXD ）
*cputimer0

RS232

*****************************************************************************/
#include "DSP28x_Project.h"// Device Headerfile and Examples Include File

/* CRC 高位字节值表 */
const Uint16 auchCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
} ;

/* CRC低位字节值表*/
const Uint16 auchCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
0x43, 0x83, 0x41, 0x81, 0x80, 0x40
} ;

/**************************************************
               宏定义
**************************************************/
#define Local       1    //slave adress
#define COIL          32    //定义共享线圈个数
/********************补充***********************/
#define REG          32    //定义共享寄存器个数
#define TX_Busy       1    //发送忙,禁止再次发送
#define TX_Success    0    //发送成功,等待下次发送
/********************补充***********************/

/************************************************
               函数声明
***************************************************/
/***************MODBUS操作函数****************/
void ResolveModbus(void);//解析功能码，确定执行何种功能；
void ReadCoil(void); //功能1 01 读线圈状态00001-09999 位操作单个或多个
void ReadHoldRegisters(void); //功能3 03 读保持寄存器40001-49999 字操作单个或多个
/*补充*/void ForceSingleCoil(void);       //功能5 05 写单个线圈00001-09999 位操作单个
/*补充*/void PresetSingleRegister(void);    //功能6 06 写单个保持寄存器40001-49999 字操作单个

void GetCoilVal(Uint16 Addr,Uint16 *ReadState);//读线圈状态
void GetRegisterVal(Uint16 Addr,Uint16 *ReadData);//读保持寄存器
/*补充*/void SetCoilVal(Uint16 Addr,Uint16 SetState);//设定线圈状态
/*补充*/void SetRegisterVal(Uint16 addr,Uint16 tempData);//写单个保持寄存器值
Uint16 Crc16(Uint16 *puchMsg, Uint16 usDataLen);//CRC校验
/***************MODBUS操作函数****************/
__interrupt void cpu_timer0_Isr(void);//cpu定时器timer0中断函数
__interrupt void scibRx_Isr(void);//fifo接收中断函数
void scibTx(void);
void scib_fifo_init(void);//scib  初始化函数
void MODBUS(void);

Uint16 RdataB [32];//读数据缓冲数组
Uint16 SdataB [32];//发送数据缓冲数组
Uint16 shared_Coil[COIL] = {1,0,0,1,0,0,1,1,1,1,0,0,0,0};//共享线圈
Uint16 shared_Reg[REG] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};//共享寄存器
Uint16 xxx = 0; //For Debug
Uint16 RdataB_Num = 0;//接收数据长度
/*补充*/Uint16 Temp_RdataB_Num = 0;//接收数据长度中间值，在写功能中使用
Uint16 SdataB_Num = 0;//发送数据长度
/*  定义标志Flag  */
Uint16 RX_OVER = 0;//接收完成标志
Uint16 Resolve_over = 0;//解析完成标志;
/********************补充***********************/
Uint16 TX_State = 0;//发送状态位(未使用);

/********************补充***********************/

void main(void)
{

InitSysCtrl();//系统时钟等初始化

InitSciGpio();//sci端口初始化

DINT; //关掉中断

InitPieCtrl(); //pie模块初始化

IER = 0x0000;//关cpu中断
IFR = 0x0000;//清cpu中断标志

InitPieVectTable();//初始化中断向量表,  经试验此句注释掉也可以，因为下边对中断向量表进行了重新赋值

EALLOW; // This is needed to write to EALLOW protected registers
PieVectTable.TINT0 = &cpu_timer0_Isr;
PieVectTable.SCIRXINTB = &scibRx_Isr; //中断向量表重新赋值（自定义中断函数的入口地址）
  // PieVectTable.SCITXINTB = &scibTxFifoIsr; //中断向量表重新赋值
EDIS; // This is needed to disable write to EALLOW protected registers

scib_fifo_init();  // 初始化 SCI-B寄存器配置

// Initialize the Device Peripheral. This function can be
//       found in DSP2833x_CpuTimers.c
   InitCpuTimers(); // For this example, only initialize the Cpu Timers

#if (CPU_FRQ_150MHZ)
// Configure CPU-Timer 0 interrupt every 5 MS(毫秒):

   ConfigCpuTimer(&CpuTimer0, 150, 5000);

#endif

#if (CPU_FRQ_100MHZ)
// Configure CPU-Timer 0, 1, and 2 to interrupt every second:
// 100MHz CPU Freq, 1 second Period (in uSeconds)

   ConfigCpuTimer(&CpuTimer0, 100, 1000000);
   ConfigCpuTimer(&CpuTimer1, 100, 1000000);
   ConfigCpuTimer(&CpuTimer2, 100, 1000000);
#endif
// To ensure precise timing, use write-only instructions to write to the entire register. Therefore, if any
// of the configuration bits are changed in ConfigCpuTimer and InitCpuTimers (in DSP2833x_CpuTimers.h), the
// below settings must also be updated.

   CpuTimer0Regs.TCR.all = 0xC010; // 清除中断标志位，使能定时器中断，停止定时器；

IER = M_INT9; // Enable CPU INT
IER |= M_INT1;

// Enable interrupts required for this. example 中断使能
PieCtrlRegs.PIECTRL.bit.ENPIE = 1; // Enable the PIE block
PieCtrlRegs.PIEIER1.bit.INTx7 = 1;// Enable TINT0 in the PIE: Group 1 interrupt 7
PieCtrlRegs.PIEIER9.bit.INTx3=1;    // PIE Group 9, INT3 SCIRXINTB SCIB
  // PieCtrlRegs.PIEIER9.bit.INTx4=1;    // PIE Group 9, INT4 SCITXINTB SCIB
EINT;//开总中断 INTM

// Step 6. IDLE loop. Just sit and loop forever (optional):
  while (1)
{

   MODBUS();

}

}

/***************************************************
                  函数定义
***************************************************/

__interrupt void scibRx_Isr(void)//接收中断服务子程序
{
CpuTimer0Regs.TCR.bit.TSS=1; //关闭
CpuTimer0Regs.TCR.bit.TRB=1; //重新装载
CpuTimer0Regs.TCR.bit.TSS=0; //打开

//if(ScibRegs.SCIRXST.bit.RXRDY !=1)  //  XRDY =1 for empty state
   RdataB[RdataB_Num++]=ScibRegs.SCIRXBUF.all; // 将移位寄存器中的数据读到缓存

/************************************************************************
*此处应添加判断接收长度功能，防止由于未知原因接收数据过长，将内存吃掉  *
*例如可以设置n<len_MAX(某个确定的长度),如果超出则返回错误             *
*目前只是通过定时器0中断来将n,RdataB_Num清零                            *
************************************************************************/

ScibRegs.SCIFFRX.bit.RXFFOVRCLR=1; // Clear Overflow flag
ScibRegs.SCIFFRX.bit.RXFFINTCLR=1; // Clear Interrupt flag
PieCtrlRegs.PIEACK.all|=PIEACK_GROUP9;    // Issue PIE ack

}

void scibTx(void)
{
//while(TX_State == TX_Busy){}
//TX_State = TX_Busy;
   int c;
   for(c=0; c<=SdataB_Num-1; c++)
   {
   while (ScibRegs.SCICTL2.bit.TXRDY == 0) {}//查询TXRDY的值
         ScibRegs.SCITXBUF=SdataB[c];
      // DELAY_US(10);//注意：在modbus协议中，延时不能超过3.5个字节传送的时间，否则被判断为传送结束。
   }
   Resolve_over = 0;
   SdataB_Num = 0;
//TX_State = TX_Success;
}

void scib_fifo_init()
{
   Uint16 j;
   for(j= 0; j<32; j++) //缓存初始化
   {
      SdataB[j] = 0;
      RdataB[j] = 0;
   }
/**************************************************
for(i= 0; i<32; i++) //缓存初始化
   {
        shared_Coil[i] =0xff;
   }
**************************************************/

// Note: Clocks were turned on to the SCIA peripheral
      // in the InitSysCtrl() function

     ScibRegs.SCICCR.all =0x0007; // 1 stop bit,  No loopback
                                    // No parity,8 char bits,
                                    // async mode, idle-line protocol
ScibRegs.SCICTL1.all =0x0003;  // enable TX, RX, internal SCICLK,
                                    // Disable RX ERR, SLEEP, TXWAKE
ScibRegs.SCICTL2.all =0x0003;
//ScibRegs.SCICTL2.bit.TXINTENA = 1;
//ScibRegs.SCICTL2.bit.RXBKINTENA =1;
#if (CPU_FRQ_150MHZ)
      ScibRegs.SCIHBAUD =0x0001;  // 9600 baud @LSPCLK = 37.5MHz.
      ScibRegs.SCILBAUD =0x00E7;
#endif
#if (CPU_FRQ_100MHZ)
      ScibRegs.SCIHBAUD =0x0001;  // 9600 baud @LSPCLK = 20MHz.
      ScibRegs.SCILBAUD =0x0044;
#endif
ScibRegs.SCICTL1.all =0x0023;  // Relinquish SCI from Reset
ScibRegs.SCIFFTX.all=0xC028;
ScibRegs.SCIFFRX.all=0x0021;
ScibRegs.SCIFFCT.all=0x00;
ScibRegs.SCICTL1.all =0x0023;    // Relinquish SCI from Reset
ScibRegs.SCIFFTX.bit.TXFIFOXRESET=1;
ScibRegs.SCIFFRX.bit.RXFIFORESET=1;

}

__interrupt void cpu_timer0_Isr(void)
{
  // CpuTimer0.InterruptCount++;
if ( RdataB_Num>=8 )
{

RX_OVER=1;//接收完成标志 debug使用；
Temp_RdataB_Num = RdataB_Num;//将接受字节长度传给Temp_RdataB_Num保存,以备写数据使用;
RdataB_Num = 0;//接收字节数清零;

}
else
{
RdataB_Num=0;
}
// Acknowledge this interrupt to receive more interrupts from group 1
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}

void ResolveModbus(void)
{
Uint16 RM_CRCCheck = 0;

switch(RdataB[1])  //判断功能码
{
case 1://读取线圈状态

RM_CRCCheck = Crc16(RdataB,RdataB_Num-2);
if(RM_CRCCheck == RdataB[RdataB_Num-1]+(RdataB[RdataB_Num-2]<<8))
{//CRC校验正确
xxx=1;//For Debug;
ReadCoil();
}
else
{//CRC校验不正确

}
break;

case 3://读保持存储器的内容

RM_CRCCheck = Crc16(RdataB,RdataB_Num-2);
if(RM_CRCCheck == RdataB[RdataB_Num-1]+(RdataB[RdataB_Num-2]<<8))
{//CRC校验正确
ReadHoldRegisters();
}
else
{//CRC校验不正确

}
break;

case 5://设置单个线圈
RM_CRCCheck = Crc16(RdataB,RdataB_Num-2);
if(RM_CRCCheck == RdataB[RdataB_Num-1]+(RdataB[RdataB_Num-2]<<8))
{//CRC校验正确
ForceSingleCoil();
}
else
{//CRC校验不正确

}
break;

case 6://设置单个保持寄存器
RM_CRCCheck = Crc16(RdataB,RdataB_Num-2);
if(RM_CRCCheck == RdataB[RdataB_Num-1]+(RdataB[RdataB_Num-2]<<8))
{//CRC校验正确
PresetSingleRegister();
}
else
{//CRC校验不正确

}

default://从机接收到的功能码不能识别
//ModbusExcep(RdataB[1],0x01);
//SciaTx_Response();
break;
}
}

//01H 读线圈状态00001-09999 位操作单个或多个
void ReadCoil(void)
{
Uint16 AddrStart=0;       //起始地址
Uint16 TempAddr=0;
Uint16 CoilCount=0;       //线圈数目
Uint16  ByteCount=0;       //读取数据区字节个数
Uint16 RC_CRCCheck=0;       //CRC校验码
Uint16 TempData=0;
Uint16  R_i=0,R_k=0;

RX_OVER = 0;//接收完成标志清除;
AddrStart = (RdataB[2]<<8) + RdataB[3];
CoilCount = (RdataB[4]<<8) + RdataB[5];
ByteCount = CoilCount/8;
if(CoilCount%8 != 0)    //不足8位的，当作一个字节
ByteCount+=1;

/*  //不检查地址
if(AddrCheck(AddrStart,CoilCount,MaxQ))
{//有错误
return;
}
*/

TempAddr=AddrStart;
for(R_k=0; R_k<ByteCount; R_k++)
{
SdataB[R_k + 3] = 0;

for(R_i=0; R_i<8; R_i++)
{
GetCoilVal(TempAddr,&TempData);

SdataB[R_k + 3] |= TempData << R_i;
TempAddr++;

if(TempAddr >= AddrStart+CoilCount)
{ //读完寄存器内容
goto Label;
}
}
}

Label:
SdataB[0] = Local;
SdataB[1] = RdataB[1];
SdataB[2] = ByteCount;

RC_CRCCheck = Crc16(SdataB,ByteCount+3);
SdataB[ByteCount+3] = RC_CRCCheck >> 8;
SdataB[ByteCount+4] = RC_CRCCheck & 0xff;
SdataB_Num = ByteCount+5;

// while(TX_State == TX_Busy){}
Resolve_over = 1;//解析完成标志置位;

xxx = 2;//debug;

//SciaTx_Response();
}

//03H; 读保持寄存器 40001-49999 字操作单个或多个
void ReadHoldRegisters(void)
{
Uint16 AddrStart=0;                //4X寄存器起始地址
Uint16 TempAddr=0;
Uint16 RR_CRCCheck=0;
Uint16  RegistersCount=0;    //要读寄存器的个数
Uint16  ByteCount=0;    //字节计数
Uint16 TempData=0;
Uint16 i=0;

RX_OVER = 0;//接收完成标志清除;
AddrStart = (RdataB[2]<<8) + RdataB[3];
TempAddr=AddrStart;
RegistersCount = (RdataB[4]<<8) + RdataB[5];
ByteCount = RegistersCount * 2;

/* 不校验地址
if(AddrCheck(AddrStart,RegistersCount,MaxHold))
{//有错误
return;
}
*/
for(i=0;i<ByteCount;i+=2,TempAddr++)
{
GetRegisterVal(TempAddr,&TempData);
SdataB[i+3] = TempData >> 8;
SdataB[i+4] = TempData & 0xff;
}

SdataB[0] = Local;
SdataB[1] = RdataB[1];
SdataB[2] = ByteCount;
RR_CRCCheck = Crc16(SdataB,ByteCount+3);
SdataB[ByteCount+3] = RR_CRCCheck >> 8;
SdataB[ByteCount+4] = RR_CRCCheck & 0xff;
SdataB_Num = ByteCount + 5;
// while(TX_State == TX_Busy){}
Resolve_over = 1;//解析完成标志置位;

//SciaTx_Response();
}//void readRegisters(void)

//05H 写单个线圈00001-09999 位操作单个
void ForceSingleCoil(void)
{
Uint16  AddrStart=0;
Uint16  TempAddr=0;
Uint16  TempData=0;
Uint16  SetData=0;
Uint16 i=0;

AddrStart = (RdataB[2]<<8) + RdataB[3];
TempAddr = AddrStart;
SetData = (RdataB[4]<<8) + RdataB[5];

/*
if(AddrCheck(AddrStart,1,MaxQ))
{//有错误
return;
}
*/

/////////////////////////////
//这里不同的上位机可能不同，要测试一下该功能？
/////////////////////////////
if(SetData == 0xFF00)
{ //设为ON
TempData = 1;
}
else if(SetData == 0x0000)
{ //设为OFF
TempData = 0;
}

SetCoilVal(TempAddr,TempData);

for(i=0;i<RdataB_Num;i++)
{
SdataB[i] = RdataB[i];
}

SdataB_Num = Temp_RdataB_Num;
Temp_RdataB_Num = 0;
Resolve_over = 1;//解析完成标志置位;

xxx = 5;//debug;
//SciaTx_Response();
}

//06H 写单个保持寄存器40001-49999 字操作单个
void PresetSingleRegister(void)
{
Uint16  AddrStart=0;
Uint16  TempAddr=0;
Uint16  SetData=0;
Uint16 i=0;

AddrStart = (RdataB[2]<<8) + RdataB[3];
TempAddr = AddrStart;
SetData = (RdataB[4]<<8) + RdataB[5];

/*
if(AddrCheck(AddrStart,1,MaxHold))
{//有错误
return;
}
*/

SetRegisterVal(TempAddr,SetData);

for(i=0;i<RdataB_Num;i++)
{
SdataB[i] = RdataB[i];
}

SdataB_Num = Temp_RdataB_Num;
Temp_RdataB_Num = 0;
Resolve_over = 1;//解析完成标志置位;

xxx = 6;//debug;
//SciaTx_Response();
}

//#pragma CODE_SECTION(GetCoilVal, "MODBUS_CODE")
//取线圈状态
void GetCoilVal(Uint16 Addr,Uint16 *ReadState)
{
switch(Addr & 0xff)
{
case 0:
*ReadState=shared_Coil[0];
break;
case 1:
*ReadState=shared_Coil[1];
break;
case 2:
*ReadState=shared_Coil[2];
break;
case 3:
*ReadState=shared_Coil[3];
break;
case 4:
*ReadState=shared_Coil[4];
break;
case 5:
*ReadState=shared_Coil[5];
break;
case 6:
*ReadState=shared_Coil[6];
break;
case 7:
*ReadState=shared_Coil[7];
break;
case 8:
*ReadState=shared_Coil[8];
break;
case 9:
*ReadState=shared_Coil[9];
break;
case 10:
*ReadState=shared_Coil[10];
break;
case 11:
*ReadState=shared_Coil[11];
break;
case 12:
*ReadState=shared_Coil[12];
break;
case 13:
*ReadState=shared_Coil[13];
break;
case 14:
*ReadState=shared_Coil[14];
break;
case 15:
*ReadState=shared_Coil[15];
break;
case 16:
*ReadState=shared_Coil[16];
break;
case 17:
*ReadState=shared_Coil[17];
break;
case 18:
*ReadState=shared_Coil[18];
break;
case 19:
*ReadState=shared_Coil[19];
break;
case 20:
*ReadState=shared_Coil[20];
break;
case 21:
*ReadState=shared_Coil[21];
break;
case 22:
*ReadState=shared_Coil[22];
break;
case 23:
*ReadState=shared_Coil[23];
break;
case 24:
*ReadState=shared_Coil[24];
break;
case 25:
*ReadState=shared_Coil[25];
break;
case 26:
*ReadState=shared_Coil[26];
break;
case 27:
*ReadState=shared_Coil[27];
break;
case 28:
*ReadState=shared_Coil[28];
break;
case 29:
*ReadState=shared_Coil[29];
break;
case 30:
*ReadState=shared_Coil[30];
break;
case 31:
*ReadState=shared_Coil[31];
break;
/* case 32:
*ReadState=shared_Coil[32];
break;
case 33:
*ReadState=shared_Coil[33];
break;
case 34:
*ReadState=shared_Coil[34];
break;
case 35:
*ReadState=shared_Coil[35];
break;
case 36:
*ReadState=shared_Coil[36];
break;
case 37:
*ReadState=shared_Coil[37];
break;
case 38:
*ReadState=shared_Coil[38];
break;
case 39:
*ReadState=shared_Coil[39];
break;
case 40:
*ReadState=shared_Coil[40];
break;
case 41:
*ReadState=shared_Coil[41];
break;
case 42:
*ReadState=shared_Coil[42];
break;
case 43:
*ReadState=shared_Coil[43];
break;
case 44:
*ReadState=shared_Coil[44];
break;
case 45:
*ReadState=shared_Coil[45];
break;
case 46:
*ReadState=shared_Coil[46];
break;
case 47:
*ReadState=shared_Coil[47];
break;
case 48:
*ReadState=shared_Coil[48];
break;
case 49:
*ReadState=shared_Coil[49];
break;
case 50:
*ReadState=shared_Coil[50];
break;
case 51:
*ReadState=shared_Coil[51];
break;
case 52:
*ReadState=shared_Coil[52];
break;
case 53:
*ReadState=shared_Coil[53];
break;
case 54:
*ReadState=shared_Coil[54];
break;
case 55:
*ReadState=shared_Coil[55];
break;
case 56:
*ReadState=shared_Coil[56];
break;
case 57:
*ReadState=shared_Coil[57];
break;
case 58:
*ReadState=shared_Coil[58];
break;
case 59:
*ReadState=shared_Coil[59];
break;
case 60:
*ReadState=shared_Coil[60];
break;
case 61:
*ReadState=shared_Coil[61];
break;
case 62:
*ReadState=shared_Coil[62];
break;
case 63:
*ReadState=shared_Coil[63];
break;
case 64:
*ReadState=shared_Coil[64];
break;
case 65:
*ReadState=shared_Coil[65];
break;
case 66:
*ReadState=shared_Coil[66];
break;
case 67:
*ReadState=shared_Coil[67];
break;
case 68:
*ReadState=shared_Coil[68];
break;
case 69:
*ReadState=shared_Coil[69];
break;
case 70:
*ReadState=shared_Coil[70];
break;
case 71:
*ReadState=shared_Coil[71];
break;
case 72:
*ReadState=shared_Coil[72];
break;
case 73:
*ReadState=shared_Coil[73];
break;
case 74:
*ReadState=shared_Coil[74];
break;
case 75:
*ReadState=shared_Coil[75];
break;
case 76:
*ReadState=shared_Coil[76];
break;
case 77:
*ReadState=shared_Coil[77];
break;
case 78:
*ReadState=shared_Coil[78];
break;
case 79:
*ReadState=shared_Coil[79];
break;
case 80:
*ReadState=shared_Coil[80];
break;
case 81:
*ReadState=shared_Coil[81];
break;
case 82:
*ReadState=shared_Coil[82];
break;
case 83:
*ReadState=shared_Coil[83];
break;
case 84:
*ReadState=shared_Coil[84];
break;
case 85:
*ReadState=shared_Coil[85];
break;
case 86:
*ReadState=shared_Coil[86];
break;
case 87:
*ReadState=shared_Coil[87];
break;
case 88:
*ReadState=shared_Coil[88];
break;
case 89:
*ReadState=shared_Coil[89];
break;
case 90:
*ReadState=shared_Coil[90];
break;
case 91:
*ReadState=shared_Coil[91];
break;
case 92:
*ReadState=shared_Coil[92];
break;
case 93:
*ReadState=shared_Coil[93];
break;
case 94:
*ReadState=shared_Coil[94];
break;
case 95:
*ReadState=shared_Coil[95];
break;
case 96:
*ReadState=shared_Coil[96];
break;
case 97:
*ReadState=shared_Coil[97];
break;
case 98:
*ReadState=shared_Coil[98];
break;
case 99:
*ReadState=shared_Coil[99];
break;
case 100:
*ReadState=shared_Coil[100];
break;
case 101:
*ReadState=shared_Coil[101];
break;
case 102:
*ReadState=shared_Coil[102];
break;
case 103:
*ReadState=shared_Coil[103];
break;
case 104:
*ReadState=shared_Coil[104];
break;
case 105:
*ReadState=shared_Coil[105];
break;
case 106:
*ReadState=shared_Coil[106];
break;
case 107:
*ReadState=shared_Coil[107];
break;
case 108:
*ReadState=shared_Coil[108];
break;
case 109:
*ReadState=shared_Coil[109];
break;
case 110:
*ReadState=shared_Coil[110];
break;
case 111:
*ReadState=shared_Coil[111];
break;
case 112:
*ReadState=shared_Coil[112];
break;
case 113:
*ReadState=shared_Coil[113];
break;
case 114:
*ReadState=shared_Coil[114];
break;
case 115:
*ReadState=shared_Coil[115];
break;
case 116:
*ReadState=shared_Coil[116];
break;
case 117:
*ReadState=shared_Coil[117];
break;
case 118:
*ReadState=shared_Coil[118];
break;
case 119:
*ReadState=shared_Coil[119];
break;
case 120:
*ReadState=shared_Coil[120];
break;
case 121:
*ReadState=shared_Coil[121];
break;
case 122:
*ReadState=shared_Coil[122];
break;
case 123:
*ReadState=shared_Coil[123];
break;
case 124:
*ReadState=shared_Coil[124];
break;
case 125:
*ReadState=shared_Coil[125];
break;
case 126:
*ReadState=shared_Coil[126];
break;
case 127:
*ReadState=shared_Coil[127];
break;
*/
}

}

//#pragma CODE_SECTION(GetRegisterVal, "MODBUS_CODE")
/*
函数功能：读取多个保持寄存器的16进制内容
参数说明：
Addr    ---- 保持寄存器的参考地址
ReadData ---- 读取的内容
*/
void GetRegisterVal(Uint16 Addr,Uint16 *ReadData)
{
switch(Addr & 0x00ff)
{
case 0:
*ReadData=shared_Reg[0];
break;
case 1:
*ReadData=shared_Reg[1];
break;
case 2:
*ReadData=shared_Reg[2];
break;
case 3:
*ReadData=shared_Reg[3];
break;
case 4:
*ReadData=shared_Reg[4];
break;
case 5:
*ReadData=shared_Reg[5];
break;
case 6:
*ReadData=shared_Reg[6];
break;
case 7:
*ReadData=shared_Reg[7];
break;
case 8:
*ReadData=shared_Reg[8];
break;
case 9:
*ReadData=shared_Reg[9];
break;
case 10:
*ReadData=shared_Reg[10];
break;
case 11:
*ReadData=shared_Reg[11];
break;
case 12:
*ReadData=shared_Reg[12];
break;
case 13:
*ReadData=shared_Reg[13];
break;
case 14:
*ReadData=shared_Reg[14];
break;
case 15:
*ReadData=shared_Reg[15];
break;
case 16:
*ReadData=shared_Reg[16];
break;
case 17:
*ReadData=shared_Reg[17];
break;
case 18:
*ReadData=shared_Reg[18];
break;
case 19:
*ReadData=shared_Reg[19];
break;
case 20:
*ReadData=shared_Reg[20];
break;
case 21:
*ReadData=shared_Reg[21];
break;
case 22:
*ReadData=shared_Reg[22];
break;
case 23:
*ReadData=shared_Reg[23];
break;
case 24:
*ReadData=shared_Reg[24];
break;
case 25:
*ReadData=shared_Reg[25];
break;
case 26:
*ReadData=shared_Reg[26];
break;
case 27:
*ReadData=shared_Reg[27];
break;
case 28:
*ReadData=shared_Reg[28];
break;
case 29:
*ReadData=shared_Reg[29];
break;
case 30:
*ReadData=shared_Reg[30];
break;
case 31:
*ReadData=shared_Reg[31];
break;
}
}

//#pragma CODE_SECTION(SetCoilVal, "MODBUS_CODE")
//设定线圈状态
void SetCoilVal(Uint16 Addr,Uint16 SetState)
{
switch(Addr & 0xff)
{
case 0:
shared_Coil[0]=SetState;
break;
case 1:
shared_Coil[1]=SetState;
break;
case 2:
shared_Coil[2]=SetState;
break;
case 3:
shared_Coil[3]=SetState;
break;
case 4:
shared_Coil[4]=SetState;
break;
case 5:
shared_Coil[5]=SetState;
break;
case 6:
shared_Coil[6]=SetState;
break;
case 7:
shared_Coil[7]=SetState;
break;
case 8:
shared_Coil[8]=SetState;
break;
case 9:
shared_Coil[9]=SetState;
break;
case 10:
shared_Coil[10]=SetState;
break;
case 11:
shared_Coil[11]=SetState;
break;
case 12:
shared_Coil[12]=SetState;
break;
case 13:
shared_Coil[13]=SetState;
break;
case 14:
shared_Coil[14]=SetState;
break;
case 15:
shared_Coil[15]=SetState;
break;
case 16:
shared_Coil[16]=SetState;
break;
case 17:
shared_Coil[17]=SetState;
break;
case 18:
shared_Coil[18]=SetState;
break;
case 19:
shared_Coil[19]=SetState;
break;
case 20:
shared_Coil[20]=SetState;
break;
case 21:
shared_Coil[21]=SetState;
break;
case 22:
shared_Coil[22]=SetState;
break;
case 23:
shared_Coil[23]=SetState;
break;
case 24:
shared_Coil[24]=SetState;
break;
case 25:
shared_Coil[25]=SetState;
break;
case 26:
shared_Coil[26]=SetState;
break;
case 27:
shared_Coil[27]=SetState;
break;
case 28:
shared_Coil[28]=SetState;
break;
case 29:
shared_Coil[29]=SetState;
break;
case 30:
shared_Coil[30]=SetState;
break;
case 31:
shared_Coil[31]=SetState;
break;
/* case 32:
shared_Coil[32]=SetState;
break;
case 33:
shared_Coil[33]=SetState;
break;
case 34:
shared_Coil[34]=SetState;
break;
case 35:
shared_Coil[35]=SetState;
break;
case 36:
shared_Coil[36]=SetState;
break;
case 37:
shared_Coil[37]=SetState;
break;
case 38:
shared_Coil[38]=SetState;
break;
case 39:
shared_Coil[39]=SetState;
break;
case 40:
shared_Coil[40]=SetState;
break;
case 41:
shared_Coil[41]=SetState;
break;
case 42:
shared_Coil[42]=SetState;
break;
case 43:
shared_Coil[43]=SetState;
break;
case 44:
shared_Coil[44]=SetState;
break;
case 45:
shared_Coil[45]=SetState;
break;
case 46:
shared_Coil[46]=SetState;
break;
case 47:
shared_Coil[47]=SetState;
break;
case 48:
shared_Coil[48]=SetState;
break;
case 49:
shared_Coil[49]=SetState;
break;
case 50:
shared_Coil[50]=SetState;
break;
case 51:
shared_Coil[51]=SetState;
break;
case 52:
shared_Coil[52]=SetState;
break;
case 53:
shared_Coil[53]=SetState;
break;
case 54:
shared_Coil[54]=SetState;
break;
case 55:
shared_Coil[55]=SetState;
break;
case 56:
shared_Coil[56]=SetState;
break;
case 57:
shared_Coil[57]=SetState;
break;
case 58:
shared_Coil[58]=SetState;
break;
case 59:
shared_Coil[59]=SetState;
break;
case 60:
shared_Coil[60]=SetState;
break;
case 61:
shared_Coil[61]=SetState;
break;
case 62:
shared_Coil[62]=SetState;
break;
case 63:
shared_Coil[63]=SetState;
break;
case 64:
shared_Coil[64]=SetState;
break;
case 65:
shared_Coil[65]=SetState;
break;
case 66:
shared_Coil[66]=SetState;
break;
case 67:
shared_Coil[67]=SetState;
break;
case 68:
shared_Coil[68]=SetState;
break;
case 69:
shared_Coil[69]=SetState;
break;
case 70:
shared_Coil[70]=SetState;
break;
case 71:
shared_Coil[71]=SetState;
break;
case 72:
shared_Coil[72]=SetState;
break;
case 73:
shared_Coil[73]=SetState;
break;
case 74:
shared_Coil[74]=SetState;
break;
case 75:
shared_Coil[75]=SetState;
break;
case 76:
shared_Coil[76]=SetState;
break;
case 77:
shared_Coil[77]=SetState;
break;
case 78:
shared_Coil[78]=SetState;
break;
case 79:
shared_Coil[79]=SetState;
break;
case 80:
shared_Coil[80]=SetState;
break;
case 81:
shared_Coil[81]=SetState;
break;
case 82:
shared_Coil[82]=SetState;
break;
case 83:
shared_Coil[83]=SetState;
break;
case 84:
shared_Coil[84]=SetState;
break;
case 85:
shared_Coil[85]=SetState;
break;
case 86:
shared_Coil[86]=SetState;
break;
case 87:
shared_Coil[87]=SetState;
break;
case 88:
shared_Coil[88]=SetState;
break;
case 89:
shared_Coil[89]=SetState;
break;
case 90:
shared_Coil[90]=SetState;
break;
case 91:
shared_Coil[91]=SetState;
break;
case 92:
shared_Coil[92]=SetState;
break;
case 93:
shared_Coil[93]=SetState;
break;
case 94:
shared_Coil[94]=SetState;
break;
case 95:
shared_Coil[95]=SetState;
break;
case 96:
shared_Coil[96]=SetState;
break;
case 97:
shared_Coil[97]=SetState;
break;
case 98:
shared_Coil[98]=SetState;
break;
case 99:
shared_Coil[99]=SetState;
break;
case 100:
shared_Coil[100]=SetState;
break;
case 101:
shared_Coil[101]=SetState;
break;
case 102:
shared_Coil[102]=SetState;
break;
case 103:
shared_Coil[103]=SetState;
break;
case 104:
shared_Coil[104]=SetState;
break;
case 105:
shared_Coil[105]=SetState;
break;
case 106:
shared_Coil[106]=SetState;
break;
case 107:
shared_Coil[107]=SetState;
break;
case 108:
shared_Coil[108]=SetState;
break;
case 109:
shared_Coil[109]=SetState;
break;
case 110:
shared_Coil[110]=SetState;
break;
case 111:
shared_Coil[111]=SetState;
break;
case 112:
shared_Coil[112]=SetState;
break;
case 113:
shared_Coil[113]=SetState;
break;
case 114:
shared_Coil[114]=SetState;
break;
case 115:
shared_Coil[115]=SetState;
break;
case 116:
shared_Coil[116]=SetState;
break;
case 117:
shared_Coil[117]=SetState;
break;
case 118:
shared_Coil[118]=SetState;
break;
case 119:
shared_Coil[119]=SetState;
break;
case 120:
shared_Coil[120]=SetState;
break;
case 121:
shared_Coil[121]=SetState;
break;
case 122:
shared_Coil[122]=SetState;
break;
case 123:
shared_Coil[123]=SetState;
break;
case 124:
shared_Coil[124]=SetState;
break;
case 125:
shared_Coil[125]=SetState;
break;
case 126:
shared_Coil[126]=SetState;
break;
case 127:
shared_Coil[127]=SetState;
break;*/
}
}

//#pragma CODE_SECTION(SetRegisterVal, "MODBUS_CODE")
//写单个保持寄存器值
void SetRegisterVal(Uint16 addr,Uint16 tempData)
{
switch(addr & 0xff)
{
case 0:
shared_Reg[0]=tempData;
break;
case 1:
shared_Reg[1]=tempData;
break;
case 2:
shared_Reg[2]=tempData;
break;
case 3:
shared_Reg[3]=tempData;
break;
case 4:
shared_Reg[4]=tempData;
break;
case 5:
shared_Reg[5]=tempData;
break;
case 6:
shared_Reg[6]=tempData;
break;
case 7:
shared_Reg[7]=tempData;
break;
case 8:
shared_Reg[8]=tempData;
break;
case 9:
shared_Reg[9]=tempData;
break;
case 10:
shared_Reg[10]=tempData;
break;
case 11:
shared_Reg[11]=tempData;
break;
case 12:
shared_Reg[12]=tempData;
break;
case 13:
shared_Reg[13]=tempData;
break;
case 14:
shared_Reg[14]=tempData;
break;
case 15:
shared_Reg[15]=tempData;
break;
case 16:
shared_Reg[16]=tempData;
break;
case 17:
shared_Reg[17]=tempData;
break;
case 18:
shared_Reg[18]=tempData;
break;
case 19:
shared_Reg[19]=tempData;
break;
case 20:
shared_Reg[20]=tempData;
break;
case 21:
shared_Reg[21]=tempData;
break;
case 22:
shared_Reg[22]=tempData;
break;
case 23:
shared_Reg[23]=tempData;
break;
case 24:
shared_Reg[24]=tempData;
break;
case 25:
shared_Reg[25]=tempData;
break;
case 26:
shared_Reg[26]=tempData;
break;
case 27:
shared_Reg[27]=tempData;
break;
case 28:
shared_Reg[28]=tempData;
break;
case 29:
shared_Reg[29]=tempData;
break;
case 30:
shared_Reg[30]=tempData;
break;
case 31:
shared_Reg[31]=tempData;
break;
}
}

Uint16 Crc16(Uint16 *puchMsg, Uint16 usDataLen)
{
Uint16 uchCRCHi = 0xFF ;             /* 高CRC字节初始化  */
Uint16 uchCRCLo = 0xFF ;             /* 低CRC 字节初始化 */
Uint32 uIndex ;                   /* CRC循环中的索引  */
while (usDataLen--)                /* 传输消息缓冲区 */
{
uIndex = uchCRCHi ^ *puchMsg++ ; /* 计算CRC       */
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;
uchCRCLo = auchCRCLo[uIndex] ;
}
return (uchCRCHi << 8 | uchCRCLo) ;
}

void MODBUS(void)
{

if(RX_OVER)
{
ResolveModbus();
if(Resolve_over)
scibTx();
}

}