ul_frame.c

linux下的RS485的驱动 值得一看

/*******************************************************************
  uLan Communication - uL_DRV - multiplatform uLan driver

  ul_frame.c	- sending and reception of uLan message frames
                  for UART chips

  (C) Copyright 1996-2004 by Pavel Pisa - project originator
        http://cmp.felk.cvut.cz/~pisa
  (C) Copyright 1996-2004 PiKRON Ltd.
        http://www.pikron.com
  (C) Copyright 2002-2004 Petr Smolik
  

  The uLan driver project can be used and distributed 
  in compliance with any of next licenses
   - GPL - GNU Public License
     See file COPYING for details.
   - LGPL - Lesser GNU Public License
   - MPL - Mozilla Public License
   - and other licenses added by project originator

  Code can be modified and re-distributed under any combination
  of the above listed licenses. If contributor does not agree with
  some of the licenses, he/she can delete appropriate line.
  WARNING: if you delete all lines, you are not allowed to
  distribute code or sources in any form.
 *******************************************************************/


/*******************************************************************/
/* Frame begin/end */

/*-- Helper functions for sndbeg --*/

int uld_sndbeg_2(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  udrv->char_buff=udrv->con_cmd;
  UL_FNEXT(*udrv->fnc_sndch);
  return UL_RC_PROC;
};

int uld_sndbeg_1(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  udrv->char_buff=udrv->char_buff=udrv->con_sadr;
  UL_FCALL2(*udrv->fnc_sndch,uld_sndbeg_2);
  return UL_RC_PROC;
};

/*** Send frame begin ***/
int uld_sndbeg(ul_drv *udrv, int ret_code)
{
  udrv->xor_sum=0;
  if(udrv->con_flg&4) udrv->char_buff=UL_BEG;
  else udrv->char_buff=udrv->con_dadr|0x100;
  UL_FCALL2(*udrv->fnc_sndch,uld_sndbeg_1);
  return UL_RC_PROC;
};

/*-- Helper functions for sndend --*/

int uld_sndend_3(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  UL_FRET;
  if(ret_code<0) return ret_code;
  if(udrv->char_buff==UL_ACK) return UL_RC_PROC;
  if(udrv->char_buff==UL_NAK) return UL_RC_ENAK;
  if(udrv->char_buff==UL_WAK) return UL_RC_EWAK;
  return UL_RC_EREPLY;
};

int uld_sndend_2(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  if(!(udrv->con_flg&1))
  {
    UL_FRET;
    return UL_RC_PROC;
  };
  udrv->wait_time=4;
  UL_FCALL2(*udrv->fnc_wait,uld_sndend_3);
  return UL_RC_PROC;
};

int uld_sndend_1(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  udrv->char_buff=udrv->xor_sum&0xFF;
  UL_FCALL2(*udrv->fnc_sndch,uld_sndend_2);
  return UL_RC_PROC;
};

/*** Send frame end ***/
int uld_sndend(ul_drv *udrv, int ret_code)
{
  static int sndend_arr[]={UL_END,UL_ARQ,UL_PRQ,UL_AAP};
  udrv->char_buff=sndend_arr[udrv->con_flg];
  UL_FCALL2(*udrv->fnc_sndch,uld_sndend_1);
  return UL_RC_PROC;
};

/*-- Helper functions for recbeg --*/

int uld_recbeg_3(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  if(udrv->char_buff&0xFF00) {UL_FRET; return UL_RC_ERECBEG;};
  udrv->con_cmd=(uchar)udrv->char_buff;
  UL_FRET;
  return UL_RC_PROC;
};

int uld_recbeg_2(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  if(udrv->char_buff&0xFF00) {UL_FRET; return UL_RC_ERECBEG;};
  udrv->con_sadr=(uchar)udrv->char_buff;
  udrv->wait_time=4;
  UL_FCALL2(*udrv->fnc_wait,uld_recbeg_3);
  return UL_RC_PROC;
};

int uld_recbeg_1(ul_drv *udrv, int ret_code)
{
  if((udrv->char_buff!=(udrv->my_adr|0x100))&&
     (udrv->char_buff!=0x100)&&
     ((udrv->char_buff!=UL_BEG)||(!(udrv->con_flg&8))))
  { UL_FRET;
    if((udrv->char_buff&0x180)==0x100)
     return UL_RC_ERECADR;
    else
     return UL_RC_ERECBEG;
  };
  udrv->con_dadr=udrv->char_buff&0xFF;
  udrv->con_flg|=8;
  udrv->wait_time=4;
  UL_FCALL2(*udrv->fnc_wait,uld_recbeg_2);
  return UL_RC_PROC;
};

/*** Receive frame begin ***/
int uld_recbeg(ul_drv *udrv, int ret_code)
{
  udrv->xor_sum=0;
  udrv->wait_time=4;
  UL_FCALL2(*udrv->fnc_wait,uld_recbeg_1);
  return UL_RC_PROC;
};

/*-- Helper functions for recend --*/

int uld_recend_3(ul_drv *udrv, int ret_code)
{
  UL_FRET;
  if(udrv->con_flg&0xC0) return UL_RC_ERECEND;
  return UL_RC_PROC;
};

int uld_recend_2(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  if(udrv->char_buff&0xFF00) {UL_FRET; return UL_RC_ERECPROT;};
  if((udrv->xor_sum-1)&0xFF) udrv->con_flg|=0x80;
  if(!(udrv->con_flg&1))
  {
    UL_FRET;
    if(udrv->con_flg&0xC0) return UL_RC_ERECEND;
    return UL_RC_PROC;
  };
  if(udrv->con_flg&0x80) udrv->char_buff=UL_NAK;
  else if(udrv->con_flg&0x40) udrv->char_buff=UL_WAK;
  else udrv->char_buff=UL_ACK;
  UL_FCALL2(*udrv->fnc_sndch,uld_recend_3);
  return UL_RC_PROC;
};

int uld_recend_1(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FRET;return ret_code;};
  if(!(udrv->char_buff&0x100))
  {
    udrv->wait_time=4;
    UL_FCALL(*udrv->fnc_wait);
    udrv->con_flg|=0x80;
    return UL_RC_PROC;
  };
  udrv->con_flg&=~3;
  switch(udrv->char_buff)
  {
    case UL_END: break;
    case UL_ARQ: udrv->con_flg|=1; break;
    case UL_PRQ: udrv->con_flg|=2; break;
    case UL_AAP: udrv->con_flg|=3; break;
    default: UL_FRET; return UL_RC_ERECPROT;
  };
  udrv->wait_time=4;
  UL_FCALL2(*udrv->fnc_wait,uld_recend_2);
  return UL_RC_PROC;
};

/*** Receive frame end ***/
int uld_recend(ul_drv *udrv, int ret_code)
{
  if((udrv->char_buff&0xFF00)==0x100) 
  {
    UL_FNEXT(uld_recend_1);
  }else{
    udrv->wait_time=4;
    UL_FCALL2(*udrv->fnc_wait,uld_recend_1);
  };
  return UL_RC_PROC;
};


/*******************************************************************/
/* Message and frame proccessor */

int uld_prmess_frame(ul_drv *udrv, int ret_code);
int uld_prmess(ul_drv *udrv, int ret_code);

/*-- Helper functions for prmess --*/
int uld_prmess_error(ul_drv *udrv, int ret_code)
{
  UL_FRET;
  return ret_code;
};

int uld_prmess_next(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FNEXT(uld_prmess_error);return UL_RC_EPRMESS;};
  if(UL_BLK_HEAD(udrv->con_frame).flg&UL_BFL_TAIL)
  {
    if(UL_BLK_HEAD(udrv->con_frame).next)
    {
      udrv->con_frame=UL_BLK_HEAD(udrv->con_frame).next;
      UL_FNEXT(uld_prmess_frame);
      return UL_RC_PROC;
    };
    UL_FRET;
    return UL_RC_ENOTAIL;
  };
  UL_FRET;
  return UL_RC_PROC;
};

int uld_prmess_rec2(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FNEXT(uld_prmess_error);return UL_RC_EPRMESS;};
  UL_FCALL2(uld_recend,uld_prmess_next);
  return UL_RC_PROC;
};

int uld_prmess_rec1(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FNEXT(uld_prmess_error);return UL_RC_EPRMESS;};
  UL_BLK_HEAD(udrv->con_frame).dadr=udrv->con_dadr;
  UL_BLK_HEAD(udrv->con_frame).sadr=udrv->con_sadr;
  UL_BLK_HEAD(udrv->con_frame).cmd=udrv->con_cmd;
  UL_FCALL2(uld_recdata,uld_prmess_rec2);
  return UL_RC_PROC;
};

int uld_prmess_snd2(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FNEXT(uld_prmess_error);return UL_RC_EPRMESS;};
  UL_FCALL2(uld_sndend,uld_prmess_next);
  return UL_RC_PROC;
};

int uld_prmess_snd1(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FNEXT(uld_prmess_error);return UL_RC_EPRMESS;};
  UL_FCALL2(uld_snddata,uld_prmess_snd2);
  return UL_RC_PROC;
};

int uld_prmess_frame(ul_drv *udrv, int ret_code)
{
  if(ret_code<0) {UL_FNEXT(uld_prmess_error);return UL_RC_EPRMESS;};
  if(UL_BLK_HEAD(udrv->con_frame).flg&UL_BFL_SND)
  {
    udrv->con_dadr=UL_BLK_HEAD(udrv->con_frame).dadr;
    udrv->con_sadr=UL_BLK_HEAD(udrv->con_frame).sadr;
    udrv->con_cmd=UL_BLK_HEAD(udrv->con_frame).cmd;
    udrv->con_flg=UL_BLK_HEAD(udrv->con_frame).flg&3;
    UL_FCALL2(uld_sndbeg,uld_prmess_snd1);
  }
  else if(UL_BLK_HEAD(udrv->con_frame).flg&UL_BFL_REC)
  {
    udrv->con_flg=8;
    UL_FCALL2(uld_recbeg,uld_prmess_rec1);
  }
  else UL_FNEXT(uld_prmess_next);
  return UL_RC_PROC;
};

/*** Proccess one outgoing message ***/
int uld_prmess(ul_drv *udrv, int ret_code)
{
  if(!udrv->con_message)
  {
    UL_FRET;
    return UL_RC_PROC;
  };
  udrv->con_frame=udrv->con_message;
  UL_FNEXT(uld_prmess_frame);
  return UL_RC_PROC;
};