framerm.nc

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

      for (i = 0;i < HDLC_QUEUESIZE; i++) {
        gMsgRcvTbl[i].pMsg = &gMsgRcvBuf[i];
        gMsgRcvTbl[i].Length = 0;
        gMsgRcvTbl[i].Token = 0;
      }
      gTxState = TXSTATE_IDLE;
      gTxByteCnt = 0;
      gTxLength = 0;
      gTxRunningCRC = 0;
      gpTxMsg = NULL;
      
      gRxState = RXSTATE_NOSYNC;
      gRxHeadIndex = 0;
      gRxTailIndex = 0;
      gRxByteCnt = 0;
      gRxRunningCRC = 0;
      gpRxBuf = (uint8_t *)gMsgRcvTbl[gRxHeadIndex].pMsg;
    }
  }

  command result_t StdControl.init() {
    HDLCInitialize();
    return call ByteControl.init();
  }

  command result_t StdControl.start() {
    HDLCInitialize();
    return call ByteControl.start();
  }
  
  command result_t StdControl.stop() {
    return call ByteControl.stop();
  }

  
  command result_t BareSendMsg.send(TOS_MsgPtr pMsg) {
    result_t Result = SUCCESS;

    atomic {
      if (!(gFlags & FLAGS_DATAPEND)) {
       gFlags |= FLAGS_DATAPEND; 
       gpTxMsg = pMsg;
       //gTxLength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
       //gTxProto = PROTO_PACKET_NOACK;
      }
      else {
        Result = FAIL;
      }
    }

    if (Result == SUCCESS) {
      Result = StartTx();
    }

    return Result;
  }

  command result_t TokenReceiveMsg.ReflectToken(uint8_t Token) {
    result_t Result = SUCCESS;

    atomic {
      if (!(gFlags & FLAGS_TOKENPEND)) {
        gFlags |= FLAGS_TOKENPEND;
        gTxTokenBuf = Token;
      }
      else {
        Result = FAIL;
      }
    }

    if (Result == SUCCESS) {
      Result = StartTx();
    }

    return Result;
  }

  async event result_t ByteComm.rxByteReady(uint8_t data, bool error, uint16_t strength) {

    switch (gRxState) {

    case RXSTATE_NOSYNC:  //waiting for a framesync 
      if ((data == HDLC_FLAG_BYTE) && (gMsgRcvTbl[gRxHeadIndex].Length == 0)) {
	  //syncbyte found - initialize things
        gMsgRcvTbl[gRxHeadIndex].Token = 0;
		gRxByteCnt = gRxRunningCRC = 0;
        gpRxBuf = (uint8_t *)gMsgRcvTbl[gRxHeadIndex].pMsg;
    	gRxState = RXSTATE_PROTO; 
      }
      break;

    case RXSTATE_PROTO:	   //may be at start of Frame - do some tests
      if (data == HDLC_FLAG_BYTE) {
        break;
      }
      gMsgRcvTbl[gRxHeadIndex].Proto = data;
      gRxRunningCRC = crcByte(gRxRunningCRC,data);
      switch (data) {
      case PROTO_PACKET_ACK:	   //FrameSync for packet requiring an acknowledge
		gRxState = RXSTATE_TOKEN;
		break;
      case PROTO_PACKET_NOACK:	   //Framesync for standard packet (no acknowledge)
		gRxState = RXSTATE_INFO;
		break;
      default:  // PROTO_ACK packets are not handled
		gRxState = RXSTATE_NOSYNC;	 //not a Framesync, go back to idle
		break;
      }//case data
      break;

    case RXSTATE_TOKEN:
      if (data == HDLC_FLAG_BYTE) {
        gRxState = RXSTATE_NOSYNC;
      }
      else if (data == HDLC_CTLESC_BYTE) {
        gMsgRcvTbl[gRxHeadIndex].Token = 0x20;
      }
      else {
        gMsgRcvTbl[gRxHeadIndex].Token ^= data;
        gRxRunningCRC = crcByte(gRxRunningCRC,gMsgRcvTbl[gRxHeadIndex].Token);
        gRxState = RXSTATE_INFO;
      }
      break;


    case RXSTATE_INFO:	   //Handle incomming packet now that we are synced to frame
      if (gRxByteCnt > HDLC_MTU) {	  //Packet too long 
		gRxByteCnt = gRxRunningCRC = 0;
		gMsgRcvTbl[gRxHeadIndex].Length = 0;
		gMsgRcvTbl[gRxHeadIndex].Token = 0;
		gRxState = RXSTATE_NOSYNC;
      }
      else if (data == HDLC_CTLESC_BYTE) {
		gRxState = RXSTATE_ESC;			   //handle escaped bytes - 0x7D
      }
      else if (data == HDLC_FLAG_BYTE) {
		if (gRxByteCnt >= 2) {		 //at END of packet (FLAG_BYTE is FRAME footer
		//fetch the received CRC
		  uint16_t usRcvdCRC = (gpRxBuf[fRemapRxPos(gRxByteCnt-1)] & 0xff);
		  usRcvdCRC = (usRcvdCRC << 8) | fRemapRxPos(gpRxBuf[(gRxByteCnt-2)] & 0xff);
#ifdef MICA2MSGTYPE
//DEBUG - FORCE CRC OK
		  gRxRunningCRC= usRcvdCRC;
#endif
		  if (usRcvdCRC == gRxRunningCRC) {
		    gMsgRcvTbl[gRxHeadIndex].Length = gRxByteCnt - 2;
		    post PacketRcvd();
		    gRxHeadIndex++; gRxHeadIndex %= HDLC_QUEUESIZE;
          	}
          else {
            gMsgRcvTbl[gRxHeadIndex].Length = 0;
            gMsgRcvTbl[gRxHeadIndex].Token = 0;
          	}
          if (gMsgRcvTbl[gRxHeadIndex].Length == 0) {
             gpRxBuf = (uint8_t *)gMsgRcvTbl[gRxHeadIndex].pMsg;
            gRxState = RXSTATE_PROTO;
          	}
          else {
            gRxState = RXSTATE_NOSYNC;
	  		}//if usRcvdCRC
		}//if gRXBytecnt
		else {
			gMsgRcvTbl[gRxHeadIndex].Length = 0;
			gMsgRcvTbl[gRxHeadIndex].Token = 0;
			gRxState = RXSTATE_NOSYNC;
			}
		gRxByteCnt = gRxRunningCRC = 0;
		} //if data	= HDLC_FLAG_BYTE
		else {	//standard byte - now we must shuffle it into the correct CC2420 Msg position
			gpRxBuf[fRemapRxPos(gRxByteCnt)] = data;
			if (gRxByteCnt >= 2) {
				gRxRunningCRC = crcByte(gRxRunningCRC,gpRxBuf[(gRxByteCnt-2)]);	//start computing CRC-need remap
			}
			gRxByteCnt++; 
			}
		break;

    case RXSTATE_ESC:	  //last byte was escape character, remap this byte to correct value
      if (data == HDLC_FLAG_BYTE) {
	// Error case, fail and resync
	gRxByteCnt = gRxRunningCRC = 0;
	gMsgRcvTbl[gRxHeadIndex].Length = 0;
	gMsgRcvTbl[gRxHeadIndex].Token = 0;
	gRxState = RXSTATE_NOSYNC;
      }
      else {
	data = data ^ 0x20;
        gpRxBuf[fRemapRxPos(gRxByteCnt)] = data;
	if (gRxByteCnt >= 2) {
	  gRxRunningCRC = crcByte(gRxRunningCRC,gpRxBuf[(gRxByteCnt-2)]);
	}
	gRxByteCnt++;
	gRxState = RXSTATE_INFO;
      }
      break;

    default:
      gRxState = RXSTATE_NOSYNC;
      break;
    }

    return SUCCESS;
  }
//*****************************************************************************
  result_t TxArbitraryByte(uint8_t inByte) {
    if ((inByte == HDLC_FLAG_BYTE) || (inByte == HDLC_CTLESC_BYTE)) {
      atomic {
        gPrevTxState = gTxState;
        gTxState = TXSTATE_ESC;
        gTxEscByte = inByte;
      }
      inByte = HDLC_CTLESC_BYTE;
    }
    
    return call ByteComm.txByte(inByte);
  }
    
  async event result_t ByteComm.txByteReady(bool LastByteSuccess) {
    result_t TxResult = SUCCESS;
    uint8_t nextByte;

    if (LastByteSuccess != TRUE) {
      atomic gTxState = TXSTATE_ERROR;
      post PacketSent();
      return SUCCESS;
    }

    switch (gTxState) {

    case TXSTATE_PROTO:
      gTxState = TXSTATE_INFO;
      gTxRunningCRC = crcByte(gTxRunningCRC,gTxProto);
      TxResult = call ByteComm.txByte(gTxProto);
      break;
      
    case TXSTATE_INFO:
      if (gTxProto == PROTO_ACK)
	nextByte = gpTxBuf[0];
      else
	nextByte = gpTxBuf[gTxByteCnt];
      gTxRunningCRC = crcByte(gTxRunningCRC,nextByte);
      gTxByteCnt++;
#ifdef MICA2MSGTYPE	  //shuffle bytes into MICA2 order
      if(gTxByteCnt == 10)
       gTxByteCnt = 0;	  //insert TOSMsg Length field  from CC2420Msg[0]
      if(gTxByteCnt == 1) 
      	gTxByteCnt = 10;	 //back to TOSMsg.data
#endif 
      if (gTxByteCnt >= gTxLength) {
	gTxState = TXSTATE_FCS1;
      }
      
      TxResult = TxArbitraryByte(nextByte);
      break;
      
    case TXSTATE_ESC:

      TxResult = call ByteComm.txByte((gTxEscByte ^ 0x20));
      gTxState = gPrevTxState;
      break;
	
    case TXSTATE_FCS1:
      nextByte = (uint8_t)(gTxRunningCRC & 0xff); // LSB
      gTxState = TXSTATE_FCS2;
      TxResult = TxArbitraryByte(nextByte);
      break;

    case TXSTATE_FCS2:
      nextByte = (uint8_t)((gTxRunningCRC >> 8) & 0xff); // MSB
      gTxState = TXSTATE_ENDFLAG;
      TxResult = TxArbitraryByte(nextByte);
      break;

    case TXSTATE_ENDFLAG:
      gTxState = TXSTATE_FINISH;
      TxResult = call ByteComm.txByte(HDLC_FLAG_BYTE);

      break;

    case TXSTATE_FINISH:
    case TXSTATE_ERROR:

    default:
      break;

    }

    if (TxResult != SUCCESS) {
      gTxState = TXSTATE_ERROR;
      post PacketSent();
    }

    return SUCCESS;
  }

  async event result_t ByteComm.txDone() {

    if (gTxState == TXSTATE_FINISH) {
      gTxState = TXSTATE_IDLE;
      post PacketSent();
    }
    
    return SUCCESS;
  }


  default event TOS_MsgPtr ReceiveMsg.receive(TOS_MsgPtr Msg) {
    return Msg;
  }

  default event TOS_MsgPtr TokenReceiveMsg.receive(TOS_MsgPtr Msg,uint8_t Token) {
    return Msg;
  }
}