mainproc.~c

linux serial example

#include "common.h"
#include "PublishCard.c"


void ACK()
{
 WriteBuffer[0]=0xaa;
 WriteBuffer[1]=0xdd;
 WriteToComm(comPort,2);
}

void NAK()
{
 WriteBuffer[0]=0xaa;
 WriteBuffer[1]=0xee;
 WriteToComm(comPort,2);
}

void SetDebug(unsigned char Debug)
{
 DEBUG=Debug;
}

int GetCommDataLength(int Device_Handle)
{
 int pcbLength;
 pcbLength=0;
 ioctl(Device_Handle,FIONREAD,&pcbLength);
 return pcbLength;
}

int  AutoDetect(int Device_Handle)
{
 int r,l;
 r=0;
 for(;;)
 {
  l=0;
  l=GetCommDataLength(Device_Handle);
  if(l==0)
  {
   if(r<50000)r++;
   else return 0;
  }
  else return l;
 }
}
//3妙
int  ShortBlockDetect(int Device_Handle)
{
 int r,l;
 r=0;
 for(;;)
 {
  l=0;
  l=GetCommDataLength(Device_Handle);
  if(l==0)
  {
   if(r<25000)r++;
   else return 0;
  }
  else return l;
 }
}

void delay(unsigned long dly)
{
 while(dly!=0)
 {
  dly-=1;
  dly+=1;
  dly-=1;
  dly+=1;
  dly-=1;
  dly+=1;
  dly-=1;
 };
}

void ListenAllDeviceOnRead_Error()
{
 int rel;
 fd_set DeviceRead;   //设备读准备就绪;
 fd_set DeviceError; // 设备出现错误
 int    DeviceMax;
 for(;;)
 {
  DeviceMax=0;
  FD_ZERO(&DeviceRead);
  FD_ZERO(&DeviceError);
 // FD_SET(ListenPort,&DeviceRead);
//  FD_SET(HS0,&DeviceRead);
  FD_SET(HS1,&DeviceRead);
  FD_SET(HS2,&DeviceRead);
  FD_SET(HS4,&DeviceRead);
  FD_SET(HS5,&DeviceRead);
/*  if(SocketConnect.Socket_Handle!=-1)
  {
   FD_SET(SocketConnect.Socket_Handle,&DeviceRead);
   FD_SET(SocketConnect.Socket_Handle,&DeviceError);
   DeviceMax=SocketConnect.Socket_Handle;
  }
  if(DeviceMax<ListenPort)DeviceMax=ListenPort;*/
  DeviceMax=HS1;
  if(HS1>DeviceMax)DeviceMax=HS1;
  if(HS2>DeviceMax)DeviceMax=HS2;
  if(HS4>DeviceMax)DeviceMax=HS4;
  if(HS5>DeviceMax)DeviceMax=HS5;
  rel=select(DeviceMax+1,&DeviceRead,NULL,NULL,NULL);
  if(rel<=0)continue;
/*  if(FD_ISSET(ListenPort,&DeviceRead))
  {
   if(SocketConnect.Socket_Handle==-1)
    rel=ListenProcess();
  }
  if(SocketConnect.Socket_Handle!=-1)
  {
   if(FD_ISSET(SocketConnect.Socket_Handle,&DeviceRead))
   {
    rel=recv(SocketConnect.Socket_Handle,&SocketCommand,SocketReadLength,0);
    if(rel<=0)
     continue;
    else
     ProcessReceive(SocketConnect.Socket_Handle);
   }
  }*/
  if(FD_ISSET(HS0,&DeviceRead))
  {
   mTerminalControl();
  }
  if(FD_ISSET(HS1,&DeviceRead))
  {
  // rel=ReadFromComm(HS1,0);
  }
  if(FD_ISSET(HS2,&DeviceRead))
  {
   rel=ReadFromComm(HS2,0);
   if(rel>=0)
    ExecMAPCFunc(Command,HS2,rel);
  }
  if(FD_ISSET(HS4,&DeviceRead))
  {
   rel=ReadFromComm(HS4,0);
   if(rel>=0)
    ExecMAPCFunc(Command,HS4,rel);
  }
  if(FD_ISSET(HS5,&DeviceRead))
  {
//   if(inBusy==0x55aa)continue;
   rel=ReadFromComm(HS5,0);
   if(rel>=0)
    ExecIOCOFunc(Command);
  }
 };
}

void PrintToNetwork(unsigned char *buff)
{
 int i,l;
 l=strlen(buff);
 printf("%s\r",buff);
}

//---------------------------------------------------------------------------
// 初始化并打开设备
// 如果设备打开出错，返回 -1
int InitilizeComm(int comPort,int Baud,int DataLength,int StopLength,int Partery)
{
 int fd;
 struct termios COMOption;
 //打开设备
 //bzero(COMOption sizeof(struct termios));
 switch(comPort)
 {
  case 0:HS0=open("/dev/ttyS0",O_RDWR | O_NOCTTY);fd=HS0;break;
  case 1:HS1=open("/dev/ttyS1",O_RDWR | O_NOCTTY);fd=HS1;break;
  case 2:HS2=open("/dev/ttyS2",O_RDWR | O_NOCTTY);fd=HS2;break;
  case 3:HS3=open("/dev/ttyS3",O_RDWR | O_NOCTTY);fd=HS3;break;
  case 4:HS4=open("/dev/ttyS4",O_RDWR | O_NOCTTY);fd=HS4;break;
  case 5:HS5=open("/dev/ttyS5",O_RDWR | O_NOCTTY);fd=HS5;break;
 }

 if(fd<0)return -1;
 //允许接收，并设为本地模式
 COMOption.c_cflag |=(CLOCAL | CREAD);

 //如果没有制定奇偶校验
 if(Partery==-1)
 {
  COMOption.c_cflag&=~PARENB;
  COMOption.c_cflag&=~PARODD;
 }
 else if(Partery/2==0)//如果指定偶校验
 {
  COMOption.c_cflag|=PARENB;
  COMOption.c_cflag&=~PARODD;
 }
 else                        //否则就是奇校验
 {
   COMOption.c_cflag&=~PARENB;
   COMOption.c_cflag|=PARODD;
 }
 COMOption.c_cflag&=~CSTOPB;      //
 COMOption.c_cflag&=~CSIZE;       //

 if(DataLength==8)COMOption.c_cflag|=CS8;
 else if(DataLength==7)COMOption.c_cflag|=CS7;
 else COMOption.c_cflag|=CS8;

 switch(Baud)
 {
  case 1200:cfsetispeed(&COMOption,B1200);cfsetospeed(&COMOption,B1200);break;
  case 2400:cfsetispeed(&COMOption,B2400);cfsetospeed(&COMOption,B2400);break;
  case 4800:cfsetispeed(&COMOption,B4800);cfsetospeed(&COMOption,B4800);break;
  case 9600:cfsetispeed(&COMOption,B9600);cfsetospeed(&COMOption,B9600);break;
  case 19200:cfsetispeed(&COMOption,B19200);cfsetospeed(&COMOption,B19200);break;
  case 38400:cfsetispeed(&COMOption,B38400);cfsetospeed(&COMOption,B38400);break;
  case 57600:cfsetispeed(&COMOption,B57600);cfsetospeed(&COMOption,B57600);break;
  default:cfsetispeed(&COMOption,B9600);cfsetospeed(&COMOption,B9600);break;
 }
 tcflush(fd, TCIFLUSH);
 tcsetattr(fd,TCSANOW,&COMOption);
 fcntl(fd,F_SETFL,O_NONBLOCK);
 CLR_DTR(fd);
 CLR_RTS(fd);
 printf("COM%i 初始化完成 波特率 :%i,该设备未发现错误\n",comPort,Baud);
 return 0;
}

int ReadFromComm(int comPort,int Length)
{
 int pcbRead,i,rel,to,ph,pe;
 unsigned char chh,crc;
 unsigned char cht,tmp,buf[256],cv;
 cht=0;
 RDataLength=0;
 i=0;
 chh=0;
 p=0;
 rel=0;
 ph=false;
 pe=false;
 for(;;)
 {
  pcbRead=read(comPort,&tmp,1);
  if(pcbRead<=0)
  {
   i+=1;
   if(i<200)continue;
   else
   {
    to=1;
    break;
   }
  }
  if(ph)
  {
   if(tmp==0xaa && chh==0xaa)
   {
    cv^=0xaa;
    continue;
   }
   else if(chh==0xaa && tmp==0xcc)
   {
    pe=true;
    cv^=0xcc;
    pcbRead=read(comPort,&crc,1);
    if(pcbRead>0)
    {
     if(crc==cv)ACK();
     else NAK();
      break;
    }
   }
   else if(chh=0xaa && tmp==0xdd)break;
   else if(chh=0xaa && tmp==0xee)
   {
    WriteToComm(comPort,WDataLength);
   }
   else
   {
    DataBuffer[p++]=tmp;
    chh=tmp;
    cv^=tmp;
    continue;
   }
  }
  if(chh==0xaa && tmp==0xbb)
  {
   ph=true;
   cv=0xaa ^ 0xbb;
   continue;
  }
 }
 if(!pe)return -3;
 //tcflush(comPort, TCIFLUSH);

 //读回数据后，判断设备类型
 if(to==1)return -2;
 Command=buf[0];
//  Result=CanverBSYNToContent(comPort);
// if(Result==0xaadd)return -1;
 if(comPort!=HS5)
 {
  if(GET_RTS(comPort)==1)return 0;
  else return 1;
 }
 else
 {
  cht=*(unsigned char*)COM5_MCR;
  cht=cht<<6;
  if((cht & 0xc0)==0xc0) //串口5设备A
   return 0;
  else if((cht & 0xc0)==0x40)
   return 1;
  else if((cht & 0xc0)==0x80)
   return 2;
  else if((cht & 0xc0)==0x00)
   return 3;
 }
}

int ReadFromComm6003(int comPort,int Length)
{
 int pcbRead,i,rel;
 unsigned char buf[256];
 RDataLength=0;
 i=0;
 for(;;)
 {
  pcbRead=read(comPort,&buf,256);
  if(pcbRead<=0)
  {
   if(i<200)
   {
    i++;
    continue;
   }
   return -1;
  }
  for(i=0;i<pcbRead;i++)
   ReadBuffer[RDataLength++]=buf[i];
  if(RDataLength+pcbRead-3>=ReadBuffer[1])
   break;
 }
 tcflush(comPort, TCIFLUSH);
 if(GET_RTS(comPort)==1)
 {
  Canver6003ToContent(HS3);
  }
 else                   //串口3设备B
 {
  Canver6003ToContent(HS3);
 }
}


int WriteToComm(int comPort,int Length)
{
  return write(comPort,WriteBuffer,Length);
}

//-----------------------------------------------------------------------------
// 将数据转换成BSYN格式的数据，准备向串口发送

int CanverContentToBSYN(int comPort)
{
 int i,p;
 unsigned char ch,chk;
 p=0;
 chk=0xaa^0xbb^Command;
 WriteBuffer[p++]=0xaa;
 WriteBuffer[p++]=0xbb;
 WriteBuffer[p++]=Command;
 for(i=0;i<DataLength;i++)
 {
  ch=DataBuffer[i];
  chk=chk^ch;
  if(ch==0xaa)
  {
   WriteBuffer[p++]=ch;
   WriteBuffer[p++]=ch;
   chk=chk^ch;
   continue;
  }
  else WriteBuffer[p++]=ch;
 }
 WriteBuffer[p++]=0xaa;
 WriteBuffer[p++]=0xcc;
 chk=chk^0xaa^0xcc;
 WriteBuffer[p++]=chk;
 WDataLength=p;
#ifdef __DEBUG__
 printf("Send To Comm:\n");
 for(i=0;i<WDataLength;i++)
  printf("%x ",WriteBuffer[i]);
 printf("\nSend END\n");
#endif
}

//----------------------------------------------------------------------------
// 将数据转换成6003格式的数据，准备向串口发送

int CanverContentTo6003(int comPort)
{
 unsigned char CheckCode;
 int i;
 WDataLength=0;
 WriteBuffer[WDataLength++]=P6003H;
 WriteBuffer[WDataLength++]=DataLength+1;
 WriteBuffer[WDataLength++]=Command;
 CheckCode=WriteBuffer[0]^WriteBuffer[1]^WriteBuffer[2];
 if(DataLength>1)
 {
  for(i=0;i<DataLength;i++)
  {
   WriteBuffer[WDataLength++]=DataBuffer[i];
   CheckCode=CheckCode^WriteBuffer[i+3];
  }
 }
 WriteBuffer[WDataLength++]=CheckCode;
 WriteBuffer[WDataLength++]=P6003E;
#ifdef __DEBUG__
 printf("Send To 6003 Content\n");
 for(i=0;i<WDataLength;i++)
  printf("%x ",WriteBuffer[i]);
 printf("\n");
#endif
}

//-----------------------------------------------------------------------
// 将接收到的BSYN格式的数据转换成普通数据格式
// 函数执行正确，返回0 将接收的数据存放在DataBuffer中
// 如果包头错误  反回 0xaadd 这是一条正应答
// 如果包尾错误  返回 0xaaee 这是一条负应答
// 如果校验值错误返回 0xccee 收到的数据校验和错误，但数据已经放在DataBuffer中
// 如果要转换的数据长度为0 返回-1
// 如果包头错误 返回 -2 同时要求重发该数据
// 如果包尾错误 返回 -3 同时要求重发该数据
//-----------------------------------------------------------------------
int CanverBSYNToContent(int comPort)
{