/*!
 * Displays the Tracking data over serial
 */
void dispRawRange()
{
    unsigned int j;

    const char us_rng_string[] = "US Range: ";
    const char ir_string[] = "IR Range: ";
    const char separator[] = "\t";
    char unitsR[] = "mm";
    char num[5];

    unsigned int irRange = rawRangeIR();
    unsigned int usRange = rawRangeUS();

    // If in tracking mode, Display the Azimuth, Elevation and Range
    if (m_currentMenu.menuID == RANGE_RAW && transmitComplete())
    {
        sendROM(CLEAR_LINE_STRING);
        transChar('\r');
        transmit(us_rng_string);
        sprintf(num, "%u", usRange);
        transmit(num);
        transmit(unitsR);
        transmit(separator);

        transmit(ir_string);
        sprintf(num, "%u", irRange);
        transmit(num);
        transmit(unitsR);
    }
}
void dispSearching()
{
    // Clear display and search!
    if (m_currentMenu.menuID == TRACKING && transmitComplete())
    {
        // Transmit the buffer to clear the extra chars
        transChar('\r');
        transmit(CLEAR_LINE_STRING);
        transChar('\r');
        sendROM(autoSearching);

    }
}
/*!
 * Displays the Tracking data over serial
 */
void dispTrack(TrackingData target)
{
    unsigned int j;

    const char rng_string[] = "Range: ";
    const char inc_string[] = "Elevation: ";
    const char az_string[] = "Azimuth: ";
    const char separator[] = "\t";
    char unitsR[] = "mm";
    char unitsD[] = "deg";
    char num[5];

    if (target.azimuth > 100 || target.azimuth < -100) return;

    // If in tracking mode, Display the Azimuth, Elevation and Range
    if (m_currentMenu.menuID == TRACKING && transmitComplete())
    {
        sendROM(CLEAR_LINE_STRING);
        transChar('\r');
        transmit(rng_string);
        sprintf(num, "%d", target.range);
        transmit(num);
        transmit(unitsR);
        transmit(separator);

        transmit(az_string);

        sprintf(num, "%d", target.azimuth);
        transmit(num);
        transmit(unitsD);
        transmit(separator);

        transmit(inc_string);
        sprintf(num, "%d", target.elevation);
        transmit(num);
        transmit(unitsD);
        transmit(separator);
    }
}
Beispiel #4
0
/* called by the main application to poll for events */
void usbll_poll( void )
{
	int epNum ;
	unsigned gstate ;
	unsigned isr = UDP->UDP_ISR ;
	if( isr != prevISR ){
		prevISR = isr ;
	}
	
	if( isr & AT91C_UDP_EPINT0 ){
		UDP->UDP_ICR = AT91C_UDP_EPINT0 ;
	}

	if( isr & AT91C_UDP_WAKEUP ){
		DEBUGMSG( "UDP_WAKEUP\r\n" );
		UDP->UDP_ICR = AT91C_UDP_WAKEUP ;
	}

	if( isr & AT91C_UDP_RXRSM ){
		DEBUGMSG( "UDP_RXRSM\r\n" );
		UDP->UDP_ICR = AT91C_UDP_RXRSM ;
	}

	if( isr & AT91C_UDP_EXTRSM ){
		DEBUGMSG( "UDP_EXTRSM\r\n" );
		UDP->UDP_ICR = AT91C_UDP_EXTRSM ;
	}

	if( isr & AT91C_UDP_SOFINT ){
//		DEBUGMSG( "UDP_SOFINT\r\n" );
		UDP->UDP_ICR = AT91C_UDP_SOFINT ;
	}

	if( isr & AT91C_UDP_ENDBUSRES ){
//		write( DEFUART, "GLBSTATE == " ); writeHex( DEFUART, UDP->UDP_GLBSTATE ); write( DEFUART, "\r\n" );
		UDP->UDP_FADDR = AT91C_UDP_FEN ;
		UDP_CLEAREPFLAGS(&UDP->UDP_GLBSTATE,AT91C_UDP_CONFG|AT91C_UDP_FADDEN);
		UDP->UDP_RSTEP = 0xffffffff ;
		UDP->UDP_RSTEP = 0 ;
		UDP_SETEPFLAGS(UDP->UDP_CSR + 0, AT91C_UDP_EPEDS);
                UDP_CLEAREPFLAGS(UDP->UDP_CSR + 0, AT91C_UDP_DIR);
		UDP->UDP_ICR = AT91C_UDP_ENDBUSRES ;
		abortTransmitters();
//		write( DEFUART, "UDP_ENDBUSRES 0x" );writeHex( DEFUART, UDP->UDP_GLBSTATE ); write( DEFUART, "\r\n" );
	}

	gstate = UDP->UDP_GLBSTATE; 

	for( epNum = 0 ; epNum < UDP_MAXENDPOINTS ; epNum++ ){
		unsigned int dStatus = UDP->UDP_CSR[epNum];

		if( dStatus & AT91C_UDP_TXCOMP ){
			transmitComplete(epNum);
		} // transmit completed

		if( dStatus & AT91C_UDP_RXSETUP ){
			unsigned char setupBuf[16];
			unsigned short rxLength = ( dStatus >> 16 ) & 0x7FF ;
			if( sizeof(struct S_usb_request) <= rxLength ){
                                struct S_usb_request const *rxSetup = (struct S_usb_request const *)setupBuf ;
                                rxLength = sizeof(*rxSetup);
				unsigned i ;
                                unsigned char volatile *const fifo = (unsigned char *)&UDP->UDP_FDR[epNum];
				for( i = 0 ; i < rxLength ; i++ ){
					setupBuf[i] = *fifo ;
				}
				if( rxSetup->bmRequestType & 0x80) {
					UDP_SETEPFLAGS(UDP->UDP_CSR + epNum, AT91C_UDP_DIR);
				}

				UDP_CLEAREPFLAGS(UDP->UDP_CSR + epNum, AT91C_UDP_RXSETUP);

				if( 0 != (UDP->UDP_CSR[epNum] & (AT91C_UDP_TXPKTRDY|AT91C_UDP_TXCOMP|AT91C_UDP_STALLSENT)) ){
					write( DEFUART, "rxSetup: txPending\r\n" );
				}

				if( setupCallback ){
					completeTransmit(epNum);
					setupCallback( setupOpaque, setupBuf, rxLength );
				}
			}
			else {
				write( DEFUART, "rxSetup too small 0x" ); writeHexChar( DEFUART, rxLength ); write( DEFUART, "\r\n" );
				UDP_CLEAREPFLAGS(UDP->UDP_CSR + epNum, AT91C_UDP_RXSETUP);
			}
		}
		
		if( dStatus & AT91C_UDP_STALLSENT ){
			UDP_CLEAREPFLAGS(UDP->UDP_CSR + epNum, AT91C_UDP_STALLSENT);
		}

		unsigned int rxMask = dStatus & (AT91C_UDP_RX_DATA_BK0|AT91C_UDP_RX_DATA_BK1);
		if( rxMask ){
			rxData(epNum,rxMask);
		} // received something
	}