示例#1
0
//*****************************************************************************
//
// Main routine for the mouse.
//
//*****************************************************************************
void
USBMouseMain(void)
{
    //
    // Disable interrupts while changing the variables below.
    //
    IntMasterDisable();

    switch(sMouseState.eState)
    {
        case MOUSE_PENDING:
        {
            //
            // Send the report since there is one pending.
            //
            USBDHIDMouseStateChange((void *)&g_sMouseDevice,
                                    (uint8_t)sMouseState.i32X,
                                    (uint8_t)sMouseState.i32Y,
                                    sMouseState.ui8Buttons);
            //
            // Clear out the report data so that pending data does not
            // continually accumulate.
            //
            sMouseState.i32X = 0;
            sMouseState.i32Y = 0;

            if(sMouseState.ui8Buttons)
            {
                //
                // Need to always send out that all buttons are released.
                //
                sMouseState.ui8Buttons = 0;
                sMouseState.eState = MOUSE_SENDING_PEND;
            }
            else
            {
                //
                // Switch to sending state and wait for the transmit to be
                // complete.
                //
                sMouseState.eState = MOUSE_SENDING;
            }

            break;
        }
        case MOUSE_DISCONNECT:
        case MOUSE_SENDING:
        case MOUSE_SENDING_PEND:
        case MOUSE_IDLE:
        default:
        {
            break;
        }
    }

    //
    // Enable interrupts now that the main loop is complete.
    //
    IntMasterEnable();
}
示例#2
0
//*****************************************************************************
//
// This function provides simulated movements of the mouse.
//
//*****************************************************************************
void
MoveHandler(void)
{
    unsigned long ulRetcode;
    char cDeltaX, cDeltaY;

    //
    // Determine the direction to move the mouse.
    //
    ulRetcode = g_ulSysTickCount % (4 * SYSTICKS_PER_SECOND);
    if(ulRetcode < SYSTICKS_PER_SECOND)
    {
        cDeltaX = MOUSE_MOVE_INC;
        cDeltaY = 0;
    }
    else if(ulRetcode < (2 * SYSTICKS_PER_SECOND))
    {
        cDeltaX = 0;
        cDeltaY = MOUSE_MOVE_INC;
    }
    else if(ulRetcode < (3 * SYSTICKS_PER_SECOND))
    {
        cDeltaX = (char)MOUSE_MOVE_DEC;
        cDeltaY = 0;
    }
    else
    {
        cDeltaX = 0;
        cDeltaY = (char)MOUSE_MOVE_DEC;
    }

    //
    // Tell the HID driver to send this new report.
    //
    g_eMouseState = MOUSE_STATE_SENDING;
    ulRetcode = USBDHIDMouseStateChange((void *)&g_sMouseDevice, cDeltaX,
                                        cDeltaY, 0);

    //
    // Did we schedule the report for transmission?
    //
    if(ulRetcode == MOUSE_SUCCESS)
    {
        //
        // Wait for the host to acknowledge the transmission if all went well.
        //
        if(!WaitForSendIdle(MAX_SEND_DELAY))
        {
            //
            // The transmission failed, so assume the host disconnected and go
            // back to waiting for a new connection.
            //
            g_bConnected = false;
        }
    }
}
//*****************************************************************************
//
// This function handles updates due to touchscreen input.
//
// This function is called periodically from the main loop to check the
// touchscreen state and, if necessary, send a HID report back to the host
// system.
//
// Returns Returns \b true on success or \b false if an error is detected.
//
//*****************************************************************************
static void
TouchHandler(void)
{
    long lDeltaX, lDeltaY;
    static unsigned char ucButtons = 0;

    //
    // Is someone pressing the screen or has the button changed state?  If so,
    // we determine how far they have dragged their finger/stylus and use this
    // to calculate mouse position changes to send to the host.
    //
    if(g_bScreenPressed || (ucButtons != g_ucButtons))
    {
        //
        // Calculate how far we moved since the last time we checked.  This
        // rather odd layout prevents a compiler warning about undefined order
        // of volatile accesses.
        //
        lDeltaX = g_lScreenX;
        lDeltaX -= g_lScreenStartX;
        lDeltaY = g_lScreenY;
        lDeltaY -= g_lScreenStartY;

        //
        // Reset our start position.
        //
        g_lScreenStartX = g_lScreenX;
        g_lScreenStartY = g_lScreenY;

        //
        // Was there any movement or change in button state?
        //
        if(lDeltaX || lDeltaY || (ucButtons != g_ucButtons))
        {
            //
            // Yes - send a report back to the host after clipping the deltas
            // to the maximum we can support.
            //
            lDeltaX = (lDeltaX > 127) ? 127 : lDeltaX;
            lDeltaX = (lDeltaX < -128) ? -128 : lDeltaX;
            lDeltaY = (lDeltaY > 127) ? 127 : lDeltaY;
            lDeltaY = (lDeltaY < -128) ? -128 : lDeltaY;

            //
            // Remember the current button state.
            //
            ucButtons = g_ucButtons;

            //
            // Send the report back to the host.
            //
            USBDHIDMouseStateChange((void *)&g_sMouseDevice,
                                    (char)lDeltaX, (char)lDeltaY,
                                    ucButtons);
        }

        //
        // Update the button portion of the display.
        //
        UpdateDisplay(ucButtons, false);
    }
}
//*****************************************************************************
//
// This function handles updates due to the buttons.
//
// This function is called from the main loop each time the buttons need to
// be checked.  If it detects an update it will schedule an transfer to the
// host.
//
// Returns Returns \b true on success or \b false if an error is detected.
//
//*****************************************************************************
tBoolean
ButtonHandler(void)
{
    unsigned char ucButtons, ucChanged, ucRepeat;
    unsigned long ulRetcode;
    char cDeltaX, cDeltaY;
    tBoolean bSuccess;

    //
    // Determine the state of the pushbuttons.
    //
    ucButtons = ButtonsPoll(&ucChanged, &ucRepeat);

    //
    // Update the display to show which buttons are currently pressed.
    //
    UpdateDisplay(ucButtons);

    //
    // If we are connected to the host and the select button changed state or
    // we see a repeat message from any of the direction buttons, go ahead and
    // send a mouse state change to the host.
    //
    if((ucChanged & SELECT_BUTTON) || (ucRepeat & ~SELECT_BUTTON))
    {
        //
        // Assume no change in the position until we determine otherwise.
        //
        cDeltaX = 0;
        cDeltaY = 0;

        //
        // Up button is held down
        //
        if(BUTTON_REPEAT(UP_BUTTON, ucRepeat))
        {
            cDeltaY = MOUSE_MOVE_DEC;
        }

        //
        // Down button is held down.
        //
        if(BUTTON_REPEAT(DOWN_BUTTON, ucRepeat))
        {
            cDeltaY = MOUSE_MOVE_INC;
        }

        //
        // Left button is held down.
        //
        if(BUTTON_REPEAT(LEFT_BUTTON, ucRepeat))
        {
            cDeltaX = MOUSE_MOVE_DEC;
        }

        //
        // Right button is held down
        //
        if(BUTTON_REPEAT(RIGHT_BUTTON, ucRepeat))
        {
            cDeltaX = MOUSE_MOVE_INC;
        }

        //
        // Tell the HID driver to send this new report for us.  Note that a 0
        // in ucButtons indicates that the relevant button is pressed so we
        // set the MOUSE_REPORT_BUTTON_1 bit if SELECT_BUTTON is clear in
        // ucButtons.
        //
        DEBUG_PRINT("Sending (0x%02x, 0x%02x), button %s.\n", cDeltaX,
                    cDeltaY, ((ucButtons & SELECT_BUTTON) ? "released" :
                    "pressed"));

        g_eMouseState = MOUSE_STATE_SENDING;
        ulRetcode = USBDHIDMouseStateChange((void *)&g_sMouseDevice, cDeltaX,
                                            cDeltaY,
                                            ((ucButtons & SELECT_BUTTON) ? 0 :
                                            MOUSE_REPORT_BUTTON_1));

        //
        // Did we schedule the report for transmission?
        //
        if(ulRetcode == MOUSE_SUCCESS)
        {
            //
            // Wait for the host to acknowledge the transmission if all went
            // well.
            //
            bSuccess = WaitForSendIdle(MAX_SEND_DELAY);

            //
            // Did we time out waiting for the packet to be sent?
            //
            if (!bSuccess)
            {
                //
                // Yes - assume the host disconnected and go back to
                // waiting for a new connection.
                //
                DEBUG_PRINT("Send timed out!\n");
                g_bConnected = 0;
            }
        }
        else
        {
            //
            // An error was reported when trying to send the report. This may
            // be due to host disconnection but could also be due to a clash
            // between our attempt to send a report and the driver sending the
            // last report in response to an idle timer timeout so we don't
            // jump to the conclusion that we were disconnected in this case.
            //
            DEBUG_PRINT("Can't send report.\n");
            bSuccess = false;
        }
    }
    else
    {
        //
        // There was no change in the state of the buttons so we have nothing
        // to do.
        //
        bSuccess = true;
    }

    return(bSuccess);
}
示例#5
0
//*****************************************************************************
//
// This function handles updates due to touchscreen input.
//
// This function is called periodically from the main loop to check the
// touchscreen state and, if necessary, send a HID report back to the host
// system.
//
// Returns Returns \b true on success or \b false if an error is detected.
//
//*****************************************************************************
static void
TouchHandler(void)
{
    short lDeltaX = 0;
    short lDeltaY = 0;
    unsigned int ulLoop;
    static unsigned char ucButtons = 0;
    static unsigned int eventCount =0;

    //
    //If there is a touch event, consider this as a first touch
    //
    if(g_iTouch)
    {
        //
        //Reset the delta
        //
        lDeltaX =0;
        lDeltaY =0;
        eventCount++;

        //
        //Wait for some more event to confirm a movement
        //
        if(eventCount >= 20)
        {
            //
            //There is a movement, so reset the touch flag
            //
            g_iTouch= 0;
            //
            //Set the movement flag
            //
            g_move = 1;
            //
            //reset the event couter
            //
            eventCount = 0;
        }
        //
        //Wait for 10ms and see if still there is a movement
        //
        delay(10);
    }
    else
    {
        //
        // If there is movement
        //
        if(g_move)
        {
            //
            //Wait for some more time to confirm
            //
            delay(50);
            //
            //Reset the deltas
            //
            lDeltaX =0;
            lDeltaY =0;
            //
            //Reset the movement flag
            //
            g_move = 0;
        }
        //
        //If still not released the touch
        //
        else if(!TouchReleaseDetect())
        {
            //
            //get the current x and y
            //
            lDeltaY = g_lScreenY;
            lDeltaX = g_lScreenX;
            //
            //Calculate the delta from the previous value
            //
            lDeltaX -= g_lScreenStartX;
            lDeltaY -= g_lScreenStartY;

            delay(20);
            //
            //check is delta is more than 15, then reset to a lesser value
            //
            if(lDeltaX > 15)
                lDeltaX = 10;
            if(lDeltaX < -15)
                lDeltaX = -10;
            if(lDeltaY > 15)
                lDeltaY = 5;
            if(lDeltaY < -15)
                lDeltaY = -5;
            //
            //if there is continious touch at the same point dont allow the cursor to move
            //
            if(lDeltaX < 3 && lDeltaX > -3)
                lDeltaX =0;
            if(lDeltaY < 3 && lDeltaY > -3)
                lDeltaY =0;
            //
            //Reset the touch flag
            //
            g_iTouch = 0;
        }

    }

    //
    // Is the press within the button area?  If so, determine which
    // button has been pressed.
    //
    if(g_lScreenY >= (GrContextDpyHeightGet(&g_sContext) - BUTTON_HEIGHT))
    {
        lDeltaX =0;
        lDeltaY =0;
        //
        // Run through the list of buttons to determine which one was
        // pressed.
        //
        if(!g_released)
        {
            for(ulLoop = 0; ulLoop < NUM_MOUSE_BUTTONS; ulLoop++)
            {
                if((g_lScreenX >= g_sMouseButtons[ulLoop].usX) &&
                   (g_lScreenX < (g_sMouseButtons[ulLoop].usX +
                    g_sMouseButtons[ulLoop].usWidth)))
                {
                    g_ucButtons |= g_sMouseButtons[ulLoop].ucReportFlag;
                    break;
                }
            }
        }
        else
        {
            g_released = 0;
        }
    }

    //
    //Store the current x and y, we need it to calculate the delta
    //
    g_lScreenStartX = g_lScreenX;
    g_lScreenStartY = g_lScreenY;

    //
    // Was there any movement or change in button state?
    //
    if(lDeltaX || lDeltaY || (ucButtons != g_ucButtons))
    {
        //
        // Yes - send a report back to the host after clipping the deltas
        // to the maximum we can support.
        //
        lDeltaX = (lDeltaX > 127) ? 127 : lDeltaX;
        lDeltaX = (lDeltaX < -128) ? -128 : lDeltaX;
        lDeltaY = (lDeltaY > 127) ? 127 : lDeltaY;
        lDeltaY = (lDeltaY < -128) ? -128 : lDeltaY;

        //
        // Remember the current button state.
        //
        ucButtons = g_ucButtons;

        //
        // Send the report back to the host.
        //
        USBDHIDMouseStateChange((void *)&g_sMouseDevice,
                                (char)lDeltaX, (char)lDeltaY,
                                ucButtons);

    }

    //
    // Update the button portion of the display.
    //
    UpdateDisplay(ucButtons, false);
}