自学教程：C++ HWREGBITW函数代码示例

//*****************************************************************************//// The callback function that is called by the sound driver to indicate that// half of the sound buffer has been played.////*****************************************************************************voidSoundCallback(uint32_t ui32Half){    //    // See which half of the sound buffer has been played.    //    if(ui32Half == 0)    {        //        // The first half of the sound buffer needs to be filled.        //        HWREGBITW(&g_ui32Flags, FLAG_PING) = 1;    }    else    {        //        // The second half of the sound buffer needs to be filled.        //        HWREGBITW(&g_ui32Flags, FLAG_PONG) = 1;    }}

//*****************************************************************************//// Delay for a multiple of the system tick clock rate.////*****************************************************************************static voidDelay(unsigned long ulCount){    //    // Loop while there are more clock ticks to wait for.    //    while(ulCount--)    {        //        // Wait until a SysTick interrupt has occurred.        //        while(!HWREGBITW(&g_ulFlags, FLAG_CLOCK_TICK))        {        }        //        // Clear the SysTick interrupt flag.        //        HWREGBITW(&g_ulFlags, FLAG_CLOCK_TICK) = 0;    }}

void DataReadyIntHandler(void){	uint8_t p = ROM_GPIOPinIntStatus(ADS_DRY_PORT, true) & 0xFF;	MAP_IntDisable(INT_GPIOC);	MAP_GPIOPinIntDisable(ADS_DRY_PORT, ADS_DRY_PIN);	GPIOPinIntClear(ADS_DRY_PORT, p);	HWREGBITW(&g_ulFlags, FLAG_ADS_INT) = 1;}

//! Initialize the OLED display.//! /param ulFrequency specifies the SSI Clock Frequency to be used.//OLED初始化void OLED_Init(unsigned long ulFrequency){	unsigned long ulIdx;	//	// Enable the SSI0 and GPIO port blocks as they are needed by this driver.	//	SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIO_OLEDDC);	//	// Configure the SSI0CLK and SSIOTX pins for SSI operation.	//	GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_5);	GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_5,					 GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD_WPU);	//	// Configure the GPIO port pin used as a D/Cn signal for OLED device,	// and the port pin used to enable power to the OLED panel.	//	GPIOPinTypeGPIOOutput(GPIO_OLEDDC_BASE, GPIO_OLEDDC_PIN | GPIO_OLEDEN_PIN);	GPIOPadConfigSet(GPIO_OLEDDC_BASE, GPIO_OLEDDC_PIN | GPIO_OLEDEN_PIN,					 GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD);	GPIOPinWrite(GPIO_OLEDDC_BASE, GPIO_OLEDDC_PIN | GPIO_OLEDEN_PIN,				 GPIO_OLEDDC_PIN | GPIO_OLEDEN_PIN);	HWREGBITW(&g_ulSSIFlags, FLAG_DC_HIGH) = 1;	//	// Configure and enable the SSI0 port for master mode.	//	OLED_Enable(ulFrequency);	//	// Clear the frame buffer.	//	OLED_Clear();	//	// Initialize the SSD1329 controller.  Loop through the initialization	// sequence array, sending each command "string" to the controller.	//	for(ulIdx = 0; ulIdx < sizeof(OLED_INIT_CMD);		ulIdx += OLED_INIT_CMD[ulIdx] + 1)	{		//		// Send this command.		//		RITWriteCommand(OLED_INIT_CMD + ulIdx + 1,						OLED_INIT_CMD[ulIdx] - 1);	}}

//*****************************************************************************//// This function delays for the specified number of milliseconds.////*****************************************************************************static voidDelay(unsigned long ulNumMS){    //    // Loop one time per millisecond.    //    for(; ulNumMS != 0; ulNumMS--)    {        //        // Clear the tick flag.        //        HWREGBITW(&g_ulFlags, FLAG_TICK) = 0;        //        // Wait until the tick flag is set.        //        while(HWREGBITW(&g_ulFlags, FLAG_TICK) == 0)        {        }    }}

//*****************************************************************************//// The interrupt handler for the first timer interrupt.////*****************************************************************************voidTimer0IntHandler(void){    //    // Clear the timer interrupt.    //    ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);    //    // Toggle the flag for the first timer.    //    HWREGBITW(&g_ui32Flags, 0) ^= 1;    //    // Update the interrupt status on the display.    //    ROM_IntMasterDisable();    GrStringDraw(&g_sContext, (HWREGBITW(&g_ui32Flags, 0) ? "1" : "0"), -1, 68,                 26, 1);    ROM_IntMasterEnable();}

//****************************************************************************//// Generic event handler for the composite device.////****************************************************************************unsigned longEventHandler(void *pvCBData, unsigned long ulEvent, unsigned long ulMsgData,             void *pvMsgData){    switch(ulEvent)    {        //        // The host has connected to us and configured the device.        //        case USB_EVENT_CONNECTED:        {            //            // Now connected.            //            HWREGBITW(&g_ulFlags, FLAG_CONNECTED) = 1;            break;        }        //        // Handle the disconnect state.        //        case USB_EVENT_DISCONNECTED:        {            //            // No longer connected.            //            HWREGBITW(&g_ulFlags, FLAG_CONNECTED) = 0;            break;        }        default:        {            break;        }    }    return(0);}

//*****************************************************************************//// TCP connect//// This function attempts to connect to a TCP endpoint.//// /return None.////*****************************************************************************err_tEthClientTCPConnect(uint32_t ui32Port){    err_t eTCPReturnCode;    //    // Enable the TCP timer function calls.    //    HWREGBITW(&g_sEnet.ui32Flags, FLAG_TIMER_TCP_EN) = 1;    if(g_sEnet.psTCP)    {        //        // Initially clear out all of the TCP callbacks.        //        tcp_sent(g_sEnet.psTCP, NULL);        tcp_recv(g_sEnet.psTCP, NULL);        tcp_err(g_sEnet.psTCP, NULL);        //        // Make sure there is no lingering TCP connection.        //        tcp_close(g_sEnet.psTCP);    }    //    // Create a new TCP socket.    //    g_sEnet.psTCP = tcp_new();    //    // Check if you need to go through a proxy.    //    if(g_sEnet.pcProxyName != 0)    {        //        // Attempt to connect through the proxy server.        //        eTCPReturnCode = tcp_connect(g_sEnet.psTCP, &g_sEnet.sServerIP,                                     ui32Port, TCPConnected);    }    else    {        //        // Attempt to connect to the server directly.        //        eTCPReturnCode = tcp_connect(g_sEnet.psTCP, &g_sEnet.sServerIP,                                     ui32Port, TCPConnected);    }    return(eTCPReturnCode);}

//*****************************************************************************//// This function sets the position and comparison of the reverse soft limit// switch.////*****************************************************************************voidLimitPositionReverseSet(long lPosition, unsigned long ulLessThan){    //    // Save the positino of the reverse limit switch.    //    g_lLimitReverse = lPosition;    //    // Save the comparison flag.    //    HWREGBITW(&g_ulLimitFlags, LIMIT_FLAG_REV_LT) = ulLessThan ? 1 : 0;}

//*****************************************************************************//// This function sets the position and comparison of the forward soft limit// switch.////*****************************************************************************voidLimitPositionForwardSet(long lPosition, unsigned long ulLessThan){    //    // Save the position of the forward limit switch.    //    g_lLimitForward = lPosition;    //    // Save the comparison flag.    //    HWREGBITW(&g_ulLimitFlags, LIMIT_FLAG_FWD_LT) = ulLessThan ? 1 : 0;}

//*****************************************************************************//// In this particular example, this function merely updates an interrupt// count and sets a flag which tells the main loop to update the display.//// TODO: Update or remove this function as required by your specific// application.////*****************************************************************************voidProcessInterrupt(void){    //    // Update our interrupt counter.    //    g_ui32IntCount++;    //    // Toggle the interrupt flag telling the main loop to update the display.    //    HWREGBITW(&g_ui32Flags, 0) ^= 1;}

//****************************************************************************//// This is the interrupt handler for the SysTick interrupt.  It is called// periodically and updates a global tick counter then sets a flag to tell the// main loop to move the mouse.////****************************************************************************voidSysTickHandler(void){    //    // Increment the current tick count.    //    g_ulSysTickCount++;    //    // Set a tick event for the mouse device.    //    HWREGBITW(&g_ulFlags, FLAG_MOVE_UPDATE) = 1;}

//*****************************************************************************//// The interrupt handler for the SysTick interrupt.////*****************************************************************************voidSysTickIntHandler(void){    //    // Increment the system tick count.    //    g_ui32TickCounter++;    //    // Indicate that a SysTick interrupt has occurred.    //    HWREGBITW(&g_ui32Flags, FLAG_SYSTICK) = 1;}

//*****************************************************************************//// This function is called by SysTick once every millisecond.////*****************************************************************************voidSysTickIntHandler(void){    unsigned long ulButtons, ulIdx;    //    // Set the flag that indicates that a timer tick has occurred.    //    HWREGBITW(&g_ulFlags, FLAG_TICK) = 1;    //    // Increment the count of ticks.    //    g_ulTickCount++;    //    // Call the CAN periodic tick function.    //    CANTick();    //    // Call the push button periodic tick function.    //    ulButtons = ButtonsTick();    //    // Set the appropriate button press flags if the corresponding button was    // pressed.    //    for(ulIdx = 0;        ulIdx < (sizeof(g_ppulButtonMap) / sizeof(g_ppulButtonMap[0]));        ulIdx++)    {        if(ulButtons & g_ppulButtonMap[ulIdx][0])        {            HWREGBITW(&g_ulFlags, g_ppulButtonMap[ulIdx][1]) = 1;        }    }}

//adc ISR functionvoid adcIsr(UArg a0) {  // Pop sample from FIFO to allow clearing ADC_IRQ event  singleSample = AUXADCReadFifo();  printf ("ADC: %d/r/n",singleSample);  // Clear ADC_IRQ flag. Note: Missing driver for this.  HWREGBITW(AUX_EVCTL_BASE + AUX_EVCTL_O_EVTOMCUFLAGSCLR, AUX_EVCTL_EVTOMCUFLAGSCLR_ADC_IRQ_BITN) = 1;  // Post semaphore to wakeup task  Semaphore_post(hSem);}

//*****************************************************************************////! Disables the sound output.//!//! This function disables the sound output, muting the speaker and cancelling//! any playback that may be in progress.//!//! /return None.////*****************************************************************************voidSoundDisable(void){    //    // Cancel any song or sound effect playback that may be in progress.    //    g_pusMusic = 0;    //    // Indicate that there are no more pending transfers.    //    HWREGBITW(&g_ulDMAFlags, FLAG_TX_PENDING) = 0;}

//****************************************************************************//// This function handles notification messages from the mouse device driver.////****************************************************************************unsigned longMouseHandler(void *pvCBData, unsigned long ulEvent,             unsigned long ulMsgData, void *pvMsgData){    switch(ulEvent)    {        //        // The USB host has connected to and configured the device.        //        case USB_EVENT_CONNECTED:        {            g_eMouseState = MOUSE_STATE_IDLE;            HWREGBITW(&g_ulFlags, FLAG_CONNECTED) = 1;            break;        }        //        // The USB host has disconnected from the device.        //        case USB_EVENT_DISCONNECTED:        {            HWREGBITW(&g_ulFlags, FLAG_CONNECTED) = 0;            g_eMouseState = MOUSE_STATE_UNCONFIGURED;            break;        }        //        // A report was sent to the host.  We are not free to send another.        //        case USB_EVENT_TX_COMPLETE:        {            g_eMouseState = MOUSE_STATE_IDLE;            break;        }    }    return(0);}

//*****************************************************************************//// Initialize the Ethernet client//// This function initializes all the Ethernet components to not configured.// This tells the SysTick interrupt which timer modules to call.//// /return None.////*****************************************************************************voidEthClientInit(tEventFunction pfnEvent){    uint32_t ui32User0, ui32User1;    //    // Initialize all the Ethernet components to not configured.  This tells    // the SysTick interrupt which timer modules to call.    //    HWREGBITW(&g_sEnet.ui32Flags, FLAG_TIMER_DHCP_EN) = 0;    HWREGBITW(&g_sEnet.ui32Flags, FLAG_TIMER_DNS_EN) = 0;    HWREGBITW(&g_sEnet.ui32Flags, FLAG_TIMER_TCP_EN) = 0;    g_sEnet.eState = iEthNoConnection;    g_sEnet.pfnEvent = pfnEvent;    //    // Convert the 24/24 split MAC address from NV ram into a 32/16 split MAC    // address needed to program the hardware registers, then program the MAC    // address into the Ethernet Controller registers.    //    FlashUserGet(&ui32User0, &ui32User1);    g_sEnet.pui8MACAddr[0] = ((ui32User0 >> 0) & 0xff);    g_sEnet.pui8MACAddr[1] = ((ui32User0 >> 8) & 0xff);    g_sEnet.pui8MACAddr[2] = ((ui32User0 >> 16) & 0xff);    g_sEnet.pui8MACAddr[3] = ((ui32User1 >> 0) & 0xff);    g_sEnet.pui8MACAddr[4] = ((ui32User1 >> 8) & 0xff);    g_sEnet.pui8MACAddr[5] = ((ui32User1 >> 16) & 0xff);    lwIPInit(g_ui32SysClock, g_sEnet.pui8MACAddr, 0, 0, 0, IPADDR_USE_DHCP);    //    // Start lwIP tick interrupt.    //    HWREGBITW(&g_sEnet.ui32Flags, FLAG_TIMER_DHCP_EN) = 1;}

//*****************************************************************************//// This function was the callback function registered with the USB host audio// class driver.  The only two events that are handled at this point are the// USBH_AUDIO_EVENT_OPEN and USBH_AUDIO_EVENT_CLOSE which indicate that a new// audio device has been found or that an existing audio device has been// disconnected.////*****************************************************************************static voidAudioCallback(tUSBHostAudioInstance *psAudioInstance,              uint32_t ui32Event,              uint32_t ui32MsgParam,              void *pvBuffer){    switch(ui32Event)    {        //        // New USB audio device has been enabled.        //        case USBH_AUDIO_EVENT_OPEN:        {            //            // Set the EVENT_OPEN flag and let the main routine handle it.            //            HWREGBITW(&g_sAudioState.ui32EventFlags, EVENT_OPEN) = 1;            break;        }        //        // USB audio device has been removed.        //        case USBH_AUDIO_EVENT_CLOSE:        {            //            // Set the EVENT_CLOSE flag and let the main routine handle it.            //            HWREGBITW(&g_sAudioState.ui32EventFlags, EVENT_CLOSE) = 1;            break;        }        default:        {        }    }}

//*****************************************************************************//// This function delays for the specified number of milliseconds, aborting the// delay if the CAN update ACK is received.////*****************************************************************************static unsigned longDelayAck(unsigned long ulNumMS){    //    // Loop one time per millisecond while the CAN update ACK has not been    // received.    //    for(; (ulNumMS != 0) && (g_ulCANUpdateAck == 0); ulNumMS--)    {        //        // Clear the tick flag.        //        HWREGBITW(&g_ulFlags, FLAG_TICK) = 0;        //        // Wait until the tick flag is set or the the CAN update ACK has been        // received.        //        while((HWREGBITW(&g_ulFlags, FLAG_TICK) == 0) &&              (g_ulCANUpdateAck == 0))        {        }        //        // If the CAN update ACK was received, return and indication of that        // fact.        //        if(g_ulCANUpdateAck == 1)        {            return(1);        }    }    //    // The delay completed before the CAN update ACK was received.    //    return(0);}

//*****************************************************************************//// Indicates that an enumeration response should be sent for this device.////*****************************************************************************voidUARTIFPStatus(void){    //    // Set the Periodic Status flag.    //    HWREGBITW(&g_ulUARTFlags, UART_FLAG_PSTATUS) = 1;    //    // Generate a fake UART interrupt, during which the enumeration response    // will be sent.    //    HWREG(NVIC_SW_TRIG) = INT_UART0 - 16;}

//*****************************************************************************//// Take as many bytes from the transmit buffer as we have space for and move// them into the USB UART's transmit FIFO.////*****************************************************************************static voidUSBUARTPrimeTransmit(uint32_t ui32Base){    uint32_t ui32Read;    uint8_t ui8Char;    //    // If we are currently sending a break condition, don't receive any    // more data. We will resume transmission once the break is turned off.    //    if(HWREGBITW(&g_ui32Flags, FLAG_SENDING_BREAK))    {        return;    }    //    // If there is space in the UART FIFO, try to read some characters    // from the receive buffer to fill it again.    //    while(UARTSpaceAvail(ui32Base))    {        //        // Get a character from the buffer.        //        ui32Read = USBBufferRead((tUSBBuffer *)&g_sRxBuffer, &ui8Char, 1);        //        // Did we get a character?        //        if(ui32Read)        {            //            // Place the character in the UART transmit FIFO.            //            ROM_UARTCharPutNonBlocking(ui32Base, ui8Char);            //            // Update our count of bytes transmitted via the UART.            //            g_ui32UARTTxCount++;        }        else        {            //            // We ran out of characters so exit the function.            //            return;        }    }}

//*****************************************************************************//// This function sets or clears a break condition on the redirected UART RX// line.  A break is started when the function is called with /e bSend set to// /b true and persists until the function is called again with /e bSend set// to /b false.////*****************************************************************************static voidSendBreak(bool bSend){    //    // Are we being asked to start or stop the break condition?    //    if(!bSend)    {        //        // Remove the break condition on the line.        //        ROM_UARTBreakCtl(UART0_BASE, false);        HWREGBITW(&g_ui32Flags, FLAG_SENDING_BREAK) = 0;    }    else    {        //        // Start sending a break condition on the line.        //        ROM_UARTBreakCtl(UART0_BASE, true);        HWREGBITW(&g_ui32Flags, FLAG_SENDING_BREAK) = 1;    }}

//*****************************************************************************//// Indicates that an enumeration response should be sent for this device.////*****************************************************************************voidUARTIFEnumerate(void){    //    // Set the enumeration response flag.    //    HWREGBITW(&g_ulUARTFlags, UART_FLAG_ENUM) = 1;    //    // Generate a fake UART interrupt, during which the enumeration response    // will be sent.    //    HWREG(NVIC_SW_TRIG) = INT_UART0 - 16;}

//*****************************************************************************//// The interrupt handler for the timer interrupt.////*****************************************************************************voidTimer0IntHandler(void){    //    // Clear the timer interrupt.    //    ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);    //    // Toggle the flag for the timer.    //    HWREGBITW(&g_ulFlags, 0) = 1;    GPIOPinWrite(STP1_BASE, STP1_PLS, STP1_PLS);    SysCtlDelay(SysCtlClockGet() / 500000);    GPIOPinWrite(STP1_BASE, STP1_PLS, 0x00);}

//*****************************************************************************//// The interrupt handler for the second timer interrupt. (temperature)////*****************************************************************************voidTimer1IntHandler(void){    //    // Clear the timer interrupt.    //    ROM_TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);    //    // Clear ADC interrupt    //    ROM_ADCIntClear(ADC0_BASE, 3);    //Increment Timer A Count    TimerBCount++;    /*//    // Use the flags to Toggle the LED for this timer    //    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, g_ui32Flags);*/    //    // Toggle the flag for the temperature timer.    //    HWREGBITW(&g_ui32InterruptFlags, 0) = 1;    //    // Trigger ADC Conversion    //    ROM_ADCProcessorTrigger(ADC0_BASE, 3);    //    //Wait for ADC conversion to complete    //    while(!ROM_ADCIntStatus(ADC0_BASE, 3, false)) { //Wait for ADC to finish sampling    }	ROM_ADCSequenceDataGet(ADC0_BASE, 3, adc_value); //Get data from Sequencer 3    //    // Update the interrupt status.    //    //ROM_IntMasterDisable();    //UARTprintf("ADC Value = %d/n", adc_value[0]); //Print out the first (and only) value    //ROM_IntMasterEnable();}

//*****************************************************************************//// Determines if a given point collides with one of the spiders.  The spider// specified is ignored when doing collision detection in order to prevent a// false collision with itself (when checking to see if it is safe to move the// spider).////*****************************************************************************static int32_tSpiderCollide(int32_t i32Spider, int32_t i32X, int32_t i32Y){    int32_t i32Idx, i32DX, i32DY;    //    // Loop through all the spiders.    //    for(i32Idx = 0; i32Idx < MAX_SPIDERS; i32Idx++)    {        //        // Skip this spider if it is not alive or is the spider that should be        // ignored.        //        if((HWREGBITW(&g_ui32SpiderAlive, i32Idx) == 0) ||           (i32Idx == i32Spider))        {            continue;        }        //        // Compute the horizontal and vertical difference between this spider's        // position and the point in question.        //        i32DX = ((g_pi32SpiderX[i32Idx] > i32X) ?                 (g_pi32SpiderX[i32Idx] - i32X) :                 (i32X - g_pi32SpiderX[i32Idx]));        i32DY = ((g_pi32SpiderY[i32Idx] > i32Y) ?                 (g_pi32SpiderY[i32Idx] - i32Y) :                 (i32Y - g_pi32SpiderY[i32Idx]));        //        // Return this spider index if the point in question collides with it.        //        if((i32DX < SPIDER_WIDTH) && (i32DY < SPIDER_HEIGHT))        {            return(i32Idx);        }    }    //    // No collision was detected.    //    return(-1);}

//*****************************************************************************//// Handler for the "LinkListen" button.////*****************************************************************************voidOnListenButtonPress(tWidget *pWidget){    //    // Tell the user we're switching into "LinkFrom" mode.    //    UpdateStatus(true, "Running as listener (LinkListen)");    //    // Set the mode we will be running in.    //    g_ulMode = MODE_LISTENER;    //    // Tell the main loop to go ahead and start communication.    //    HWREGBITW(&g_ulCommandFlags, COMMAND_MODE_SET) = 1;}

//*****************************************************************************//// Enable the Speex encoder/decoder and allow the quality setting to be set// by a single decimal argument.////*****************************************************************************intCmd_speex(int argc, char *argv[]){    unsigned long ulTemp;    //    // Clear the pass through flag.    //    HWREGBITW(&g_ulFlags, FLAG_BYPASS) = 0;    //    // Check for an argument that is specifying a quality setting.    //    if(argc == 2)    {        //        // Convert the value to a numeric value.        //        ulTemp = ustrtoul(argv[1], 0, 10);        //        // Rail the quality setting at 4.        //        if(ulTemp <= 4)        {            g_iQuality = (int)ulTemp;            //            // Set the quality setting.            //            SpeexEncodeQualitySet(g_iQuality);            UARTprintf("Speex Encoder Quality set to %d/n", g_iQuality);        }        else        {            UARTprintf("Encoder Quality not changed, value must be (1-4)./n");        }    }    return(0);}

//*****************************************************************************//// Determines if a given point collides with one of the spiders.  The spider// specified is ignored when doing collision detection in order to prevent a// false collision with itself (when checking to see if it is safe to move the// spider).////*****************************************************************************static longSpiderCollide(long lSpider, long lX, long lY){    long lIdx, lDX, lDY;    //    // Loop through all the spiders.    //    for(lIdx = 0; lIdx < MAX_SPIDERS; lIdx++)    {        //        // Skip this spider if it is not alive or is the spider that should be        // ignored.        //        if((HWREGBITW(&g_ulSpiderAlive, lIdx) == 0) || (lIdx == lSpider))        {            continue;        }        //        // Compute the horizontal and vertical difference between this spider's        // position and the point in question.        //        lDX = ((g_plSpiderX[lIdx] > lX) ? (g_plSpiderX[lIdx] - lX) :               (lX - g_plSpiderX[lIdx]));        lDY = ((g_plSpiderY[lIdx] > lY) ? (g_plSpiderY[lIdx] - lY) :               (lY - g_plSpiderY[lIdx]));        //        // Return this spider index if the point in question collides with it.        //        if((lDX < SPIDER_WIDTH) && (lDY < SPIDER_HEIGHT))        {            return(lIdx);        }    }    //    // No collision was detected.    //    return(-1);}