示例#1
0
文件: phy.c 项目: cdifranco/sensorfly
void UpdateLEDs (void)
/****************************************************************************/
{
	unsigned long tiStamp;
    tiStamp = hwclock ();

#	ifdef CONFIG_USE_TX_LED
    if (txLED < tiStamp)
	{
		LED_TX(LED_OFF);
	}
#	endif
#	ifdef CONFIG_USE_RX_LED
    if (rxLED < tiStamp)
	{
		LED_RX(LED_OFF);
	}
#	endif
#	ifdef CONFIG_USE_ERR_LED
    if (errLED < tiStamp)
	{
		LED_ERR(LED_OFF);
	}
#	endif

#	ifdef CONFIG_USE_CAL_LED
	if (calLED < tiStamp)
	{
		LED_CAL(LED_OFF);
	}
#	endif
}
示例#2
0
/**
 * NTRXTxEnd:
 *
 * NTRXTxEnd() finish transmission and reset internal state.
 *
 * Returns: none
 *
 */
void NTRXTxEnd (void)
{
    MyByte8T maxArqCount;
    /*
     * get number of transmissions needed to last message
     */
    NTRXGetRegister (NA_TxArqCnt, &ntrxArqCount);
    maxArqCount = NTRXGetTxARQmax();

    if ((ntrxArqCount > maxArqCount) && (ntrxState == TxWAIT))
    {
	rcwd++;
	txIrq &= ~(TxEND);
	ntrxState = TxIDLE;
	if (ntrxCal != 0)
	{
#	   ifdef CONFIG_NTRX_AUTO_RECALIB
       tiRecal = hwclock() + calDelay;
#      endif
       NTRXAllCalibration ();
       rcwd = 0;
#      ifdef CONFIG_RECALIB_LED
       TRIGGER_LED3();
#      endif /*  CONFIG_RECALIB_LED */
	}
	lState = RANGING_READY;

#   	ifdef CONFIG_TRAFFIC_LED
    	TRIGGER_LED2();
#   	endif /* CONFIG_TRAFFIC_LED */

    }else{
	txIrq &= ~(TxEND);
	ntrxState = TxIDLE;
	if (lState != RANGING_READY)
	{
		RangingCallback_Ack(ntrxArqCount);
		lState = RANGING_ANSWER1;
	}

    }
}
示例#3
0
usc_time_t usc_MD_clock()
{

#if defined(TC_2000) || defined(TC_2000_TCMP)

#define TIMER_USED "tc2000 butterfly"

    struct 
    {
	unsigned long hi;
	unsigned long low;
    } usclock;

    get64bitclock(&usclock);
    return((usc_time_t)usclock.low);

#endif


#if defined(IPSC860)

#define TIMER_USED "ipsc"

	esize_t hwtime;
	unsigned long ustime;

	hwclock(&hwtime);
        hwtime.shigh = (hwtime.shigh & 0x7) << (sizeof(long)*8-3);
        hwtime.slow = ((hwtime.slow >> 3) & ~(0x7 << (sizeof(long)*8-3)))
				| hwtime.shigh;
        ustime = (unsigned long)hwtime.slow * 0.8;
	return( (usc_time_t) ustime);

#endif

#if defined(MEIKO_CS2)

#define TIMER_USED "meiko cs2"
/* making it look like a SUN temporarily (see *.h files also) - RMB */

/****
#include <sys/types.h>
#include <elan/elanreg.h>
#include <elan/elanctxt.h>

    struct elan_timeval t;
    unsigned int uS;

    elan_clock(elan_ctxt,&t);
    uS =  t.tv_sec*1000000 + t.tv_nsec/1000;
    return uS;
*****/
#endif


#if defined(NCUBE)
#define TIMER_USED "ncube"

   unsigned long ustime;
   double amicclk();

    ustime = (unsigned long) amicclk();
    /* printf("usc_MD_clock: returning %lu %u\n",ustime,ustime); */
    return( (usc_time_t) ustime);
#endif


#if defined(FX2800)  ||  defined(FX2800_SWITCH)

#define TIMER_USED "Alliant fx2800"
    struct hrcval temptime;

    hrcstamp(&temptime);
    return ((usc_time_t) (temptime.hv_low * 10));

#endif


#if defined(SUN) || defined(HP) || \
    defined(SUN_SOLARIS) || defined(FREEBSD) || defined(LINUX) || \
    defined(I86_SOLARIS) || defined(NETBSD) || \
    defined(BALANCE) || \
    defined(RS6000) || defined(IBM3090) || \
    defined(NEXT) || defined(TITAN) || defined(TC1000) || \
    defined(KSR)  || \
    defined(MEIKO_CS2)  || \
    defined(SGI) || defined(FX8)

#define TIMER_USED "gettimeofday"

	unsigned long ustime;
	struct timeval tp;
	struct timezone tzp;

#if defined(SUN_SOLARIS) && defined(USE_WIERDGETTIMEOFDAY)
	gettimeofday(&tp);
#else
	gettimeofday(&tp,&tzp);
#endif
	ustime = (unsigned long) tp.tv_sec;
	ustime = ustime % usc_MD_rollover_val;
	ustime = (ustime * 1000000) + (unsigned long) tp.tv_usec;

	return((usc_time_t) ustime);

#endif

#if defined(DEC5000)        
       
/*        
 *  hack by [email protected]:
 *
 *    clock resolution is 3906 us        
 *    we can do about 120 calls in 3906 us == 32 us per call        
 */        

#define TIMER_USED "dec5000"

        unsigned long ustime;        
        struct timeval tp;        
        struct timezone tzp;        
        static unsigned long last= 0;        
        static unsigned long increment= 0;        
       
        gettimeofday(&tp,&tzp);        
        ustime = (unsigned long) tp.tv_sec;        
        ustime = ustime % usc_MD_rollover_val;        
        ustime = (ustime * 1000000) + (unsigned long) tp.tv_usec;        
       
        if (last == ustime)
        {
          increment += 33L;
        }
        else
        {
          last = ustime;
          increment = 0;
        }

        return((usc_time_t) last + increment);

#endif

#ifndef TIMER_USED
    'Error - no timer code used.  Please file a bug report'
#endif
}
示例#4
0
文件: phy.c 项目: cdifranco/sensorfly
void PDCallback (void)
/****************************************************************************/
{
    MyByte8T       status;
    MyByte8T       reg[2];

	/*
	 * use 1 led to indicate message reception on the devBoard
	 * The led will stay on for a 50 ms.
     */
#   ifdef CONFIG_TRAFFIC_LED
    TRIGGER_LED_RX ();
#   endif /* CONFIG_TRAFFIC_LED */

	/*
	 * read the crc2 status register
	 */
    NTRXSPIReadByte (NA_RxCrc2Stat_O, &status);
    rxIrq = 0;

    /* check if data is valid */
    if ((status & (1 << NA_RxCrc2Stat_B)) != 0)
    {
        NTRXSetIndexReg (0);
        /* read source address */
        NTRXSPIRead (NA_RamRxSrcAddr_O, upMsg.addr, 6);
        /* read length plus additionl bits */
        NTRXSPIRead (NA_RamRxLength_O, reg, 2);

        rState = reg[1]>>5;

        /* read destination address */
#		ifdef CONFIG_NTRX_SNIFFER
        NTRXSPIRead (NA_RamRxDstAddr_O, upMsg.rxAddr, 6);
		upMsg.count++;
		upMsg.extBits = rState;
		upMsg.frameType = (status & 0x0f);
#		endif

		upMsg.len = reg[0];
        if (upMsg.len > PHY_PACKET_SIZE)
        {
		    /* restart receiver */
			if (phyPIB.rxState == PHY_RX_ON)
			{
    			NTRXSPIWriteByte (NA_RxCmdStart_O, ntrxShadowReg[NA_RxCmdStart_O]
									| (1 << NA_RxCmdStart_B)
									| (0x03 << NA_RxBufferCmd_LSB));
			}
        }
        else
        {

			if (buffSwapped == TRUE)
			{
				buffSwapped = FALSE;
				/* SWAP BUFFER for receive*/
				ntrxShadowReg[NA_SwapBbBuffers_O] &= ~(1 << NA_SwapBbBuffers_B);
				NTRXSPIWriteByte (NA_SwapBbBuffers_O, ntrxShadowReg[NA_SwapBbBuffers_O]);

				NTRXSetIndexReg (3);
			}
			else
			{
				buffSwapped = TRUE;
				/* SWAP BUFFER for receive*/
				ntrxShadowReg[NA_SwapBbBuffers_O] |= (1 << NA_SwapBbBuffers_B);
				NTRXSPIWriteByte (NA_SwapBbBuffers_O, ntrxShadowReg[NA_SwapBbBuffers_O]);

				NTRXSetIndexReg (2);
			}

			tiPhyRxTimeout_once = FALSE;
			tiPhyRxTimeout = hwclock() + phyPIB.phyRxTimeout;

			/*
			 * restart receiver and than read rx buffer. This is ok because we use
			 * buffer swapping.
			 */
			if (phyPIB.rxState == PHY_RX_ON)
			{
    			NTRXSPIWriteByte (NA_RxCmdStart_O, ntrxShadowReg[NA_RxCmdStart_O]
									| (1 << NA_RxCmdStart_B)
									| (0x03 << NA_RxBufferCmd_LSB));
			}

            NTRXSPIRead ((MyByte8T)(NA_RamRxBuffer_O & 0xFF), upMsg.data, upMsg.len);
			NTRXSetIndexReg (0);
#ifdef		CONFIG_NTRX_SNIFFER
			upMsg.value = 0xff;
			upMsg.prim = PD_DATA_INDICATION;
			SendMsgUp (&upMsg);
#else
			/*
			 * if address matching off, ignore rangingstates
			 * this path is used for normal data reception
			 * ranging is handled in the else path
			 */
			if (((ntrxShadowReg[NA_RxAddrMode_O] & (1<<NA_RxAddrMode_B)) == 0) ||
				(lState == RANGING_READY && rState == RANGING_READY))
			{
				upMsg.value = 0xff;
				upMsg.prim = PD_DATA_INDICATION;
				SendMsgUp (&upMsg);
			}
			else if((lState == RANGING_READY) && (rState == RANGING_START || rState == RANGING_FAST_START))
			{
				memcpy(rDest, upMsg.addr, 6);

				RangingCallback_Rx(upMsg.data, upMsg.len);

				if(rState == RANGING_START)
				{
					lState = RANGING_ANSWER1;
					/* send ranging packet */
					RangingMode(RANGING_ANSWER1, rDest);
				}else if (rState == RANGING_FAST_START)
				{
					lState = RANGING_FAST_ANSWER1;
					/* send ranging packet */
					RangingMode(RANGING_FAST_ANSWER1, rDest);
				}
			}
			else if((memcmp(rDest, upMsg.addr, 6) == 0) && lState == RANGING_ANSWER1 && rState == RANGING_ANSWER1)
			{
				/* received ranging data to RangingCallback_Rx
				 * (without protocol header stuff)
				 */
				RangingCallback_Rx(upMsg.data, upMsg.len);
				lState = RANGING_ANSWER2;
			}
			else if((memcmp(rDest, upMsg.addr, 6) == 0) &&
					((lState == RANGING_ANSWER2 && rState == RANGING_ANSWER2) ||
					(lState == RANGING_FAST_ANSWER1 && rState == RANGING_FAST_ANSWER1)))
			{
				/* ranging was successfull, stop timeout */
				NTRXStopBbTimer();

				/* received ranging data to RangingCallback_Rx
				 *(without protocol header stuff)
				 */
				RangingCallback_Rx(upMsg.data, upMsg.len);

				/* calculate the distance */
				rangingPIB.distance = getDistance();
				rangingPIB.rssi = getRSSI();

				if (rangingPIB.distance < 0.0)
					rangingPIB.error = STAT_RANGING_VALUE_ERROR;

				upMsg.value = 0xff;
				memcpy(upMsg.data, (MyByte8T*) &rangingPIB, sizeof(RangingPIB));
				upMsg.len  = sizeof(RangingPIB);

				if (rState == RANGING_ANSWER2)
					upMsg.prim = PD_RANGING_INDICATION;
				else if (rState == RANGING_FAST_ANSWER1)
					upMsg.prim = PD_RANGING_FAST_INDICATION;

				/* set ready for new ranging */
				lState = RANGING_READY;
				SendMsgUp (&upMsg);
			}
#			endif
        }
    }
示例#5
0
文件: phy.c 项目: cdifranco/sensorfly
void PDSap (MyMsgT *msg)
/****************************************************************************/
{
    MyByte8T txLen[2];
	static MyAddressT cacheAddr;

	/*
	 * check the message length. If the message length is bigger than
	 * the allowed buffer size the packet will be rejected.
	 */
	if (msg->len > PHY_PACKET_SIZE)
	{
		msg->prim = PD_DATA_CONFIRM;
		msg->status = PHY_BUSY_TX;
		SendMsgUp (msg);
		return;
	}

	switch(msg->prim)
	{
		case PD_DATA_REQUEST :
			/* transmitter still busy */
			if (txSendMsg != NULL)
			{

				msg->prim = PD_DATA_CONFIRM;
				msg->status = PHY_BUSY_TX;
				SendMsgUp (msg);
				return;
			}
			/*
			 * there is no break here !!!
			 * This is intentional and not a mistake.
			 */

		case PD_RANGING_ANSWER1_EXECUTE :
		case PD_RANGING_ANSWER2_EXECUTE :
		case PD_RANGING_REQUEST_EXECUTE :
		case PD_RANGING_FAST_REQUEST_EXECUTE :
		case PD_RANGING_FAST_ANSWER1_EXECUTE :


#	   		ifdef CONFIG_NTRX_AUTO_RECALIB
			if (phyPIB.recalInterval != 0)
			{
				if( tiRecal < hwclock() )
				{
					/* INFO: If the TRX sends a packet, calibration failes!
					 * In this case rcwd is not reset, but tiRecal is.
					 */
					/* normal operation mode */
					if (phyPIB.testmode == 0)
					{
						if (NTRXAllCalibration ())
						{
							tiRecal = hwclock() + phyPIB.recalInterval;
							rcwd = 0;
							TRIGGER_LED_CAL();
						}
					}
				}
			}
#	   		endif /* CONFIG_NTRX_AUTO_RECALIB */
			/* check which buffer is free to transmit data */
			if (buffSwapped ==TRUE)
			{
				/* write user data to transmit buffer in ntrx chip */
				NTRXSetIndexReg (2);
				NTRXSPIWrite ((MyByte8T)(NA_RamTxBuffer_O & 0xff), msg->data, (MyByte8T)(msg->len & 0xff));

			}else
			{
				/* write user data to transmit buffer in ntrx chip */
				NTRXSetIndexReg (3);
				NTRXSPIWrite ((MyByte8T)(NA_RamTxBuffer_O & 0xff), msg->data, (MyByte8T)(msg->len & 0xff));
			}

			NTRXSetIndexReg (0);

			/* copy the destination address to temp buffer */
			if (memcmp (cacheAddr, msg->addr, 6) != 0)
			{
				memcpy (cacheAddr, msg->addr, 6);
				NTRXSPIWrite (NA_RamTxDstAddr_O, cacheAddr, 6);
			}

			/* merge the three bits into the temp buffer */
			txLen[0] = msg->len;
			// txLen[1] = (len & 0x1F00) >> 8;
			txLen[1]  = (lState & 0x01) ? 0x20 : 0;
			txLen[1] |= (lState & 0x02) ? 0x40 : 0;
			txLen[1] |= (lState & 0x04) ? 0x80 : 0;

			NTRXSPIWrite (NA_RamTxLength_O, txLen, 2);
			ntrxState = TxSEND;

			/* mark buffers as valid and start transmission */
			NTRXSPIWriteByte (NA_TxBufferCmd_O, (1 << NA_TxCmdStart_B) | (0x03 << NA_TxBufferCmd_LSB));
			TRIGGER_LED_TX();

			txSendMsg = msg;
			break;

		case PD_RANGING_REQUEST :
		case PD_RANGING_FAST_REQUEST :
			/* transmitter still busy */
			rangingPIB.distance = -1.0;
			rangingPIB.error = STAT_NO_ERROR;

			if (txSendMsg != NULL)
			{

				msg->prim = PD_RANGING_CONFIRM;
				msg->status = PHY_BUSY_TX;
				memcpy(msg->data, (MyByte8T*) &rangingPIB, sizeof(RangingPIB));
				msg->len = sizeof(RangingPIB);
				SendMsgUp (msg);
				return;
			}

			if (lState != RANGING_READY)
			{
				txSendMsg = NULL;

				msg->prim = PD_RANGING_CONFIRM;
				msg->status = PHY_BUSY;
				memcpy(msg->data, (MyByte8T*) &rangingPIB, sizeof(RangingPIB));
				msg->len = sizeof(RangingPIB);
				SendMsgUp (msg);
				return;
			}

			memcpy(rDest, msg->addr, 6);

			if (msg->prim == PD_RANGING_REQUEST)
			{
				lState = RANGING_START;
				RangingMode(RANGING_START, msg->addr);
			}
			else if (msg->prim == PD_RANGING_FAST_REQUEST)
			{
				lState = RANGING_FAST_START;
				RangingMode(RANGING_FAST_START, msg->addr);
			}

			break;

		default:
			break;
	}
}
示例#6
0
文件: phy.c 项目: cdifranco/sensorfly
void PHYInit (void)
/****************************************************************************/
{
	phyPIB.currentChannel = PHY_CHANNEL_MIN;
	phyPIB.txPower		  = 0x3f;
	phyPIB.pwrDownMode	  = 2;
	txSendMsg			  = NULL;
	phyPIB.recalInterval  = CONFIG_NTRX_RECAL_DELAY;
	phyPIB.phyRxTimeout   = CONFIG_NTRX_PHY_RX_TIMEOUT;
	tiPhyRxTimeout 		  = hwclock() + phyPIB.phyRxTimeout;
	tiPhyRxTimeout_once	  = FALSE;
	phyPIB.arqMax 		  = CONFIG_MAX_ARQ;
	phyPIB.testmode		  = 0;
	phyPIB.fec			  = FALSE;
	trxPollMode = TRUE;

	/*
     * Clear and reset all interrupt flags of the nanoLOC chip
     */
	ntrxShadowReg[NA_TxIntsReset_O] = 0x3f;
	ntrxShadowReg[NA_RxIntsReset_O] = 0x7f;
	/*
	 * enable tx and rx interrupts
	 */
	ntrxShadowReg[NA_RxIrqEnable_O] |= ((1 << NA_RxIrqEnable_B) | (1 << NA_TxIrqEnable_B));

	NTRXResetSettings ();

	/*
     * enable CRC checks on received messages. This will cause corrupt frames to be droped
     * silently by the nanoLOC chip. The receiver is restarted automatically.
     */
    if ((ntrxShadowReg[NA_RxCrc2Mode_O] & (1<< NA_RxCrc2Mode_B)) !=  0)
	{
		ntrxShadowReg[NA_RxIntsEn_O] = (0x01 << NA_RxEnd_B);
	}
    else
	{
		ntrxShadowReg[NA_RxIntsEn_O] = ((0x01 << NA_RxEnd_B) | (0x01 << NA_RxOverflow_B));
	}
	ntrxShadowReg[NA_TxIntsEn_O] = (1 << NA_TxEnd_B);

	NTRXSPIWrite (NA_RxIrqEnable_O, ntrxShadowReg + 0x0f, 6);
    /*
     * initialize layer global variables
     */
    txIrqStatus = 0;
    rxIrqStatus = 0;
    txIrq = 0;
    rxIrq = 0;
    bbIrq = 0;
	lState = RANGING_READY;
	rState = RANGING_READY;
	ntrxShadowReg[NA_TxIntsReset_O] = 0;
	ntrxShadowReg[NA_RxIntsReset_O] = 0;

    /*
     * start the receiver of the TRX chip
     */
	if (phyPIB.rxState == PHY_RX_ON)
	{
    	NTRXSPIWriteByte (NA_RxCmdStart_O, ntrxShadowReg[NA_RxCmdStart_O]
									| (1 << NA_RxCmdStart_B)
									| (0x03 << NA_RxBufferCmd_LSB));
	}

    ntrxState    = TxIDLE;
}