mftmac.c.bak

motorola jw32 usb 源码

/*********************************************************************
 * Function:        void MACPutData(BYTE  *v, BYTE len)
 *
 * PreCondition:    MACIsPutReady() == TRUE
 *
 * Input:           b       - Buffer that is to be loaded.
 *                  len     - Number of bytes to get
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Loads given bytes into RF TX buffer.
 *
 * Note:            None
 ********************************************************************/
/*void MACPutData(BYTE  *v, BYTE len)
{
    // Copy all given bytes into TX buffer.
    BYTE i;
    if(len==0)
        return;
    if(len>APP_DATA_LENGTH)
    		len = APP_DATA_LENGTH;
        i=0;
    while( len-- )
    {
        MACPut(v[i]);
        i++;
    }
}*/
//when kb no data over time 400ms.we auto bounce kb data
void MACAutoBcKbData()
{
	BYTE i;
	for(i=0;i<KbLength;i++)
	{
		TXBUFFER[i+1]	=0;
	}
	TXBUFFER[0]=MAC_KBMAPHEAD;
	if(PutUsbData(TXBUFFER,KEYBOARDLENGTH,MAC_DEVICE_KEYBOARD)) ;
}
/*********************************************************************
 * Function:        void MACUpdateTimeoutFlags( void )
 *
 * PreCondition:    MACInit() is called
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    Frame timeout flags are updated
 *
 * Overview:        This function goes through the frame queue and
 *                  checks each frame that is currently waiting for
 *                  an acknowledge to see if it has timed out.  It
 *                  then calls the application call-back.
 *
 * Note:            None
 ********************************************************************/
static void MACUpdateTimeoutFlags( void )
{
   // if(!macState.bits.bIsEnabled)
   //   return;
  // static byte bledtick=0;      //second tick
   	 macTickDiff =	TickGetDiff(TickGet(), macMsTick);
		if (macTickDiff>TICKS_PER_SECOND)//(macBeaon.Control.bits.bCAP-2))//at lest need one slot left to send data
	    {	    
	    	if(ledDataFlag==0)
	    	{

					LED_DATA=LED_CLOSE;
					ledDataFlag = 1;
				}
				if((macBeaconTick>=8)&&(bPhyGetReady==FALSE))
					{
						macMsTick = TickGet();
						PHYSetTRXState(PHY_TRX_TX_ON);
						//------------------------------------------
						PHYCaliberateOsc();                      //caliberate 2500 osc
						//-----------------------------------------------
						PHYSetTRXState(PHY_TRX_RX_ON);
					}			
	   }
	  if(bmode==MAC_MODE_BEACON)
	  {
	  		macTickDiff = TickGetDiff(TickGet(),macKbTick);
				if ((macTickDiff==GKBOVERIME)&&(bkbounce==0))
		    {
		   	 	MACAutoBcKbData();
		   	 	bkbounce=1;
		    }
     }   

}
/****************************************************************
* function:void MACUpdateLedState(BYTE ledflag)
* input   : type:0:all led should update.
                 1:red led update
                 2:blue led update
                 3:green led update
                 4:data led update
* overview: update led state when in run mode

*****************************************************************/
/*void MACUpdateLedState(BYTE type,BYTE ledflag)
{
	if(macWarncode)         //warn state
			return;
	if(type==LED_ALL)
	{
			//LED_DATA = ledflag;
			LED_REA0 = ledflag;
		 	LED_REA1  = ledflag;
		 	LED_BLU0 = ledflag;
		 	LED_BLU1 = ledflag;
		 	LED_GRN0=  ledflag;
			LED_GRN1=  ledflag;

	}
	else if(type==LED_RED)
	{
		LED_REA0 = ledflag;
		LED_REA1  = ledflag;
	}
	else if(type==LED_BLUE)
	{
		LED_BLU1 = ledflag;
		LED_BLU0  = ledflag;
	}
	else if(type==LED_GREEN)
	{
		LED_GRN0=  ledflag;
		LED_GRN1=  ledflag;
	}
	else if(type==LED_DA)
		LED_DATA = ledflag;


}*/
/*********************************************************************
 * Function:      void MACRemapData()
 *
 * output  :      if this key  maped successfully. return 2.else if key
 	is forbid, return 0. else no map return 1
 * Overview:       map mouse key data to keyboard data for espectial
 	                 deal.
 *********************************************************************/
BYTE  MACRemapData()
{
	BYTE flag;
	BYTE  blength;
	BYTE  bkeyState;
	static BYTE boldKey=0;
	BYTE bkey = RXBuffer[0].databuffer[macRecLen] ;
	if(macCurrentFrame.frameCtrl.Control.fields.devId==MAC_DEVICE_KEYBOARD)
	   	return NOMAP;
	flag = 0;
	if(macCurrentFrame.frameCtrl.Control.fields.devId==MAC_DEVICE_MOUSE)
	{
				if(boldKey==bkey)
					return NOMAP;
					bkeyState =boldKey^bkey;
				if(bkeyState==0)//no change
					return NOMAP;
				   flag=MACGetBitNumber1(bkeyState);
					if(flag!=NODATA)
					{
					    boldKey^=Groupbit[flag];
					 	flag +=1;
					}
					if(flag>RomBitNumber)
					{
						return NOMAP;
					}
					//boldKey=bkey;
					if(flag)//key pressed ,should grab it
					{
							bmsIsMap = FALSE;
							blength = msRamMapIndex[flag].length;
						if(blength==0)  //disable map data
						 	return DISMAP;
						if(blength==1)  //NO map data
								return NOMAP;
						if(blength>MAC_KEYMAPLEN)
						{
								return NOMAP;
						}
						// begin map it
						macmsMapKey = flag;
		       bmsIsMap = TRUE;
					  return KEYBOARD_MAP; //maybe mouse move data
					}
			}
		return NOMAP;
}
/*********************************************************************
 * Function:       void MACTestSendAck(void)
 *
 *
 * Overview:        this function is test function.return receive
                    signal RSSI
 *********************************************************************/
/*static void MACTestSendAck()
{

     FRAME_CONTROL framectrl;
    bIsTest = TRUE;
    framectrl.Control.Val			=	0x00;
    framectrl.Control.fields.type	= MAC_FRAME_TESTACK;
    MACPutHeader(5, 0x00);//broadcast address 0,TEST data length 4
    // put frame control
    MACPut(framectrl.Control.Val);

    MACPut(0x00);//device address
     // put frame DATA
    MACPut(phyTransmitPower);//send power
    MACPut(RXBuffer[0].lqi	);//receive strength

    //
    MACSndDataLength  =MAC_FRAME_HEAD+2;
   	PHYDataRequest(MACSndDataLength,TXBUFFER);
   	 macStartTick =  TickGet();
}*/
void MACProcessWarn(void)
{
	BYTE btemp;
	btemp =  MACGet();  //device panid
	btemp =  MACGet();  //device channel
	LED_PWRLOW=LED_CLOSE;
	LED_FULL = LED_CLOSE;
	/*if(btemp!=macInfo.panId)
	{
		return;
	}

	if(btemp!=macCurrentChannel)
	{
		return;
	}*/
	btemp =  MACGet();  //device warncode
	macWarncode=btemp;
	if(btemp&WARN_PWRLOW)
	{
		LED_PWRLOW=LED_LIGHT;
	}
	else
		LED_PWRLOW=LED_CLOSE;
}

//switch system mode.
/*void MACProcessCmd(void)
{
	BYTE  cmd=0;
	BYTE  i=0;
	BYTE  tempmode=0;
	BYTE jkdevid=0;
	cmd = MACGet();  //get cmd data

  tempmode = 0;
		jkdevid=MACGetJkChannelId();
	//switch mac key map data buffer
	if(macCurrentFrame.frameCtrl.Control.fields.devId==MAC_DEVICE_MOUSE)
	{

			tempmode = MACGetBitNumber1(cmd);
			if(tempmode==NODATA)
			{
				return;
			}
			if((tempmode>=RomBitNumber)||(tempmode==2))
				return;
			if(tempmode>1)//no key 2 pressed mode,k1,k2,k4,k5
			{
				tempmode-=1;
			}
			if(tempmode==MsMode)
					return	;//doent switch mode
			MsMode	=tempmode ;
			//ReadFlash((byte const *)FLASH_ADDRESS[tempmode],KEYBLOCKSIZE,Ram_Key);
			if(tempmode==0)
				Modify_KeyMapIndex((BYTE const *)FLASH_ADDRESS[tempmode],KEYMAPMAXSIZE,msRamMapIndex,MAC_MSKEY_NUMBER);
			else
				Modify_KeyMapIndex((BYTE const *)FLASH_ADDRESS[tempmode],KEYMAPMAXSIZE,msRamMapIndex+1,(MAC_MSKEY_NUMBER-1));
	}
	else	if(jkdevid==MAC_DEVICE_JOYSTICK1)
	{
			if(cmd>=MAC_JKMODE_NUMBER)
					return	;//doent switch mode
			if(cmd==jk2mode)
					return	;//doent switch mode
				jk2mode	=cmd ;
			if(Modify_KeyMapIndex((BYTE const *)FLASH_ADDRESS_JK2[jk2mode],PAGESIZE,jk2RamMapIndex,MAC_JKKEY_NUMBER)) ;//again search ram index
	}
else	if(jkdevid==MAC_DEVICE_JOYSTICK0)
{

		if(cmd>=MAC_JKMODE_NUMBER)
					return	;//doent switch mode
			if(cmd==jk1mode)
					return	;//doent switch mode
				jk1mode	=cmd ;
	if(Modify_KeyMapIndex((BYTE const *)FLASH_ADDRESS_JK1[jk1mode],PAGESIZE,jk1RamMapIndex,MAC_JKKEY_NUMBER)) ;//again search ram index
}
}
*/
/*********************************************************************
 * Function:        BYTE MACTask(void)
 *
 * PreCondition:    MACInit() is called
 *
 * Input:           None
 *
 * Output:          TRUE        - If Processing is complete
 *                  FALSE       - If further processing is required
 *
 * Side Effects:    None
 *
 * Overview:        If previous frame is processed, it checks
 *                  for new RX frame.
 *                  Fetches the header and determiens if it is valid
 *                  Automatically sends ACK if remote node has
 *                  requested it.
 *                  Also performs some other automatic processing
 *                  based on the frame type.
 *                  If there is no frame in buffer, it goes through
 *                  DSN queue and calculates timeout for unack'ed
 *                  TX frames.
 *
 * Note:            This function must be called as many times as
 *                  possible to keep handling MAC frames.
 ********************************************************************/
void MACTask(void)
{
		 	//-----------------------------------------------------
    // Do not process any new frame until current one is all processed.
    //TICK diff;
   // BYTE btick;
   BYTE dataFlag=0;
    MACISR();
 	//-----------------------------------------------------
 	//send beacon
   if ( !bIsGetReady )
    {
		    if(bIsAssociated&&(macBeaon.Control.bits.bmode ==MAC_MODE_BEACON))
		    {
		         if((macBeaconTick>=BIREADY)&&(bBeaconReady==0))
      			{
      						//	LED=1;
      				      PHYSetTRXState(PHY_TRX_TX_ON);
      				 			PHYClearRxBuffer();
      				 	    MACPreBeacon()	;      				 	 
      			}
    				if(beaconflag)
    		    {
							beaconflag =  0;//PTD_PTD4=1;
    				 	MACSendBeacon();
    			 }
		   }
    }
    else if(MACIsNetworkEstablished())
    {
    	/* 	if ( macCurrentFrame.frameCtrl.Control.fields.type == MAC_FRAME_JNET )
    	 	{
        		MACSendAssociateResponse();
         }
          else */if(macCurrentFrame.frameCtrl.Control.fields.type == MAC_FRAME_DATA)
          {

  	        // Notify application of arrival of a new frame.  Since ACK
  	        // frames don't have a destination address, we receive all
  	        // of them.  So only use this callback for a non-ACK frame.
  	           if(macCurrentFrame.frameCtrl.Control.fields.devId!=MAC_DEVICE_MOUSE)
             {

		             if(bmode!=MAC_MODE_BEACON)
		             {
		             bmode       = MAC_MODE_BEACON;
		             	macBeaon.Control.bits.bmode 					=  bmode;
		             }
		            /* if(macCurrentFrame.frameCtrl.Control.fields.devId>2)
		             {
		             	 macBeaon.Control.bits.bAck = macCurrentFrame.frameCtrl.Control.fields.devId-2;
		             }*/
								 if(macCurrentFrame.frameCtrl.Control.fields.devId==MAC_DEVICE_JOYSTICK0||macCurrentFrame.frameCtrl.Control.fields.devId==MAC_DEVICE_JOYSTICK1)
								 {
								 		if(MACProcessJkData())
								 		{
								 			AppMACFrameReceived();
								 		}                                    
								 		macBeaon.Control.bits.bAck |=3;	//JK1=01,JK2=0x02								     
								 }
								 else if(macCurrentFrame.frameCtrl.Control.fields.devId==MAC_DEVICE_KEYBOARD)
								 {
								 		macKbTick=TickGet();
								 		bkbounce=0;
								 	 macBeaon.Control.bits.bAck |= MAC_ACK_KEYBOARD;
								 		AppMACFrameReceived();
								 	if(macKbPassFlag)
								 	{
								 		macKbPassFlag =0;
								 		MACPassDeviceData(MAC_DEVICE_KEYBOARD,&macKbLedState,1);
								 	}
								 }
            	}
  	        	else   if(MACRemapData()!=DISMAP)	 //mouse data map
  	        	{
  	        	//		LED_DATA^=1;
		         		 AppMACFrameReceived();
		          }
  	    }
  	    /*else if(macCurrentFrame.frameCtrl.Control.fields.type == MAC_FRAME_CHKNET)
  	    {
  	    	MACSendNetState();
  	    }
  	      else if(macCurrentFrame.frameCtrl.Control.fields.type == MAC_FRAME_CMD)
  	    {
  	    	MACProcessCmd();
  	    }*/
  	    else if(macCurrentFrame.frameCtrl.Control.fields.type == MAC_FRAME_WARN)
  	    {
  	    	MACProcessWarn();
  	    }
  	    else if ( macCurrentFrame.frameCtrl.Control.fields.type == MAC_FRAME_NETST||	macCurrentFrame.frameCtrl.Control.fields.type==MAC_FRAME_BEACON)
        {
            	if(MACProcessNetState()) ;
        }
    		MACDiscardRx();
	}
	//MACDiscardRx();
    // Update the timeout flags of all frames in the queue.
   MACUpdateTimeoutFlags();
    //EnableInterrupts;
}


/*********************************************************************
 * Function:        static BYTE MACGetHeader(void)
 *
 * PreCondition:    _MACIsGetReady() == TRUE
 *
 * Input:           None
 *
 * Output:          TRUE        - if current frame has valid header
 *                  FALSE       - if current frame does not have
 *                                valid header
 *
 * Side Effects:    None
 *