C++ UEZDeviceTableGetWorkspace函数代码示例

/*---------------------------------------------------------------------------*/
void UEZWAVConfig(TUInt8 onBoardSpeakerVolume)
{
    T_uezError error;

    if(UEZAudioAmpOpen("AMP0", &amp) == UEZ_ERROR_NONE){
        UEZAudioAmpSetLevel(amp, onBoardSpeakerVolume);
        G_AudioAmpOpen = ETrue;
    }
    
    volume = onBoardSpeakerVolume;
    error = UEZDeviceTableFind("AudioCodec0", &p_ac);
    error = UEZDeviceTableGetWorkspace(p_ac, (T_uezDeviceWorkspace **)&ac);

    (*ac)->UseConfiguration((void*)ac, 1);
    if(error != UEZ_ERROR_NONE){
        (*ac)->UseConfiguration((void*)ac, 1);
    }

    wav = UEZMemAlloc(DATA_TO_READ);
    wav2 = UEZMemAlloc(DATA_TO_READ);

    error = UEZDeviceTableFind("I2S", &p_i2s);
    error = UEZDeviceTableGetWorkspace(p_i2s, (T_uezDeviceWorkspace **)&i2s);

    (*i2s)->Configure((void*)i2s, (HAL_I2S_Callback_Transmit_Low) i2sCallBack);
    
    UEZSemaphoreCreateBinary(&wavSem);
    playStatus = EFalse;
}

/*---------------------------------------------------------------------------*/
T_uezError UEZTSOpen(
            const char * const aName,
            T_uezDevice *aDevice,
            T_uezQueue *aEventQueue)
{
    T_uezError error;
    DEVICE_TOUCHSCREEN **p;

    if (!G_tsDidInit)
        IUEZTSInitialize();

    error = UEZDeviceTableFind(aName, aDevice);
    if (error)
        return error;

    error = UEZDeviceTableGetWorkspace(*aDevice, (T_uezDeviceWorkspace **)&p);
    if (error)
        return error;

    error = (*p)->Open((void *)p);
    if (error)
        return error;

    if (aEventQueue)
        UEZTSAddQueue(*aDevice, *aEventQueue);

    return error;
}

/*---------------------------------------------------------------------------*
 * Routine:  LCD_RH320240T_Configure
 *---------------------------------------------------------------------------*
 * Description:
 *      Setup the LCD to use a particular LCD controller.
 * Inputs:
 *      void *aW                -- Workspace
 * Outputs:
 *      T_uezError               -- If the device is successfully configured,
 *                                  returns UEZ_ERROR_NONE.
 *---------------------------------------------------------------------------*/
T_uezError LCD_RH320240T_Configure(
            void *aW,
            HAL_LCDController **aLCDController,
            TUInt32 aBaseAddress,
            DEVICE_Backlight **aBacklight)
{
    T_uezDevice spi;
    T_uezDeviceWorkspace *p_spi;
//    T_uezDeviceWorkspace *p_gpio2;

    T_RH320240TWorkspace *p = (T_RH320240TWorkspace *)aW;
    p->iLCDController = aLCDController;
    p->iBaseAddress = aBaseAddress;

    p->iBacklight = aBacklight;

    UEZDeviceTableFind(p->iSPIBus, &spi);
    UEZDeviceTableGetWorkspace(spi, (T_uezDeviceWorkspace **)&p_spi);

    p->iSPI = (DEVICE_SPI_BUS **)p_spi;

    p->r.iDataMOSI = p->iCmd;
    p->r.iDataMISO = p->iCmd;
    p->r.iNumTransfers = 0;
    p->r.iBitsPerTransfer = 8;
    p->r.iRate = 9000;
    p->r.iClockOutPolarity = ETrue;//EFalse;
    p->r.iClockOutPhase = ETrue;
    p->r.iCSGPIOPort = GPIO_TO_HAL_PORT(p->iCSGPIOPin);
    p->r.iCSGPIOBit = GPIO_TO_PIN_BIT(p->iCSGPIOPin);
    p->r.iCSPolarity = EFalse; // LOW true
    return UEZ_ERROR_NONE;
}

/*---------------------------------------------------------------------------*/
T_uezError UEZI2CWrite(
        T_uezDevice aDevice,
        TUInt8 aAddress,
        TUInt32 aSpeed,
        TUInt8 *aData,
        TUInt8 aDataLength,
        TUInt32 aTimeout)
{
    T_uezError error;
    DEVICE_I2C_BUS **p;
    I2C_Request request;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **)&p);
    if (error)
        return error;

    // Fill the request structure on the stack and do a standard request
    request.iAddr = aAddress;
    request.iWriteData = aData;
    request.iWriteLength = aDataLength;
    request.iWriteTimeout = aTimeout;
    request.iSpeed = aSpeed;
    request.iReadData = 0;
    request.iReadLength = 0;
    request.iReadTimeout = 0;

    // Do the transactions and return the result
    return (*p)->ProcessRequest((void *)p, &request);
}

/******************************************************************************
* ID : 60.0
* Outline : Glyph_uEZ_Open
* Include : Glyph_uEZ_0.h
* Function Name: Glyph_uEZ_Open
* Description : Open and setup the communications channel 0.
* Argument : aHandle - the Glyph handle to setup for the LCD and Communications.
* Return Value : 0=success, not 0= error
* Calling Functions : GlyphCommOpen
******************************************************************************/
T_glyphError Glyph_uEZ_Open(T_glyphHandle aHandle)
{
    int i = 0 ;
    T_uezDevice dev;
    T_uezDeviceWorkspace *G_gpioC;
    
    if (G_spi == 0)  {
        UEZDeviceTableFind("SPI0", &dev);
        UEZDeviceTableGetWorkspace(dev, (T_uezDeviceWorkspace **)&G_spi);
        HALInterfaceFind("GPIOC", (T_halWorkspace **)&G_gpioC);

        G_request.iBitsPerTransfer = 8;
        // Chip select on Port C2 (high true)
        G_request.iCSGPIOPort = (HAL_GPIOPort **)G_gpioC;
        G_request.iCSGPIOBit = (1<<2);
        G_request.iCSPolarity = EFalse;
        G_request.iClockOutPhase = EFalse;
        G_request.iClockOutPolarity = EFalse;
        G_request.iDataMISO = 0;
        G_request.iDataMOSI = 0;
        G_request.iNumTransfers = 0;
        G_request.iRate = 12000; // 12 MHz for now

        /* Set data direction for this bit to output */
        PORTC.DDR.BIT.B3 = 1 ;   // LCD GPIO for Reset LCD
        PORT5.DDR.BIT.B1 = 1 ;   // LCD RS A0

        StartResetLCD() ;
        for (i=0;i<1000000;i++){}
        EndResetLCD() ;
        for (i=0;i<1000000;i++){}
    }

    return GLYPH_ERROR_NONE ;
}

T_uezError Keypad_NXP_PCA9555_Create(
        const char *aName,
        const char *aI2CBusName,
        TUInt8 aI2CAddr,
        const char *aExternalInterruptsName,
        TUInt8 aExternalInterruptChannel)
{
    T_Keypad_NXP_I2C_PCA9555_Workspace *p;
    T_uezDevice i2c;
    DEVICE_I2C_BUS **p_i2c;
    T_uezError error;

    UEZDeviceTableRegister(aName,
            (T_uezDeviceInterface *)&Keypad_NXP_PCA9555_Interface, 0,
            (T_uezDeviceWorkspace **)&p);

    error = UEZDeviceTableFind(aI2CBusName, &i2c);
    if (error)
        return error;
    UEZDeviceTableGetWorkspace(i2c, (T_uezDeviceWorkspace **)&p_i2c);

    error = Keypad_NXP_PCA9555_Configure(p, p_i2c, aI2CAddr, aExternalInterruptsName,
        aExternalInterruptChannel);
    return error;
}

/*---------------------------------------------------------------------------*/
T_uezError UEZEEPROMClose(T_uezDevice aDevice)
{
    DEVICE_EEPROM **p_eeprom;

    // Look up its workspace, return any errors
    return UEZDeviceTableGetWorkspace(aDevice,
        (T_uezDeviceWorkspace **)&p_eeprom);
}

/*---------------------------------------------------------------------------*/
T_uezError UEZStreamFlush(T_uezDevice aDevice) {
    T_uezError error;
    DEVICE_STREAM **p;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **) &p);
    if (error)
        return error;

    return (*p)->Flush((void *) p);
}

/*---------------------------------------------------------------------------*/
T_uezError UEZStreamControl(T_uezDevice aDevice, TUInt32 aControl,
        void *aControlData) {
    T_uezError error;
    DEVICE_STREAM **p;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **) &p);
    if (error)
        return error;

    return (*p)->Control((void *) p, aControl, aControlData);
}

/*---------------------------------------------------------------------------*/
T_uezError UEZStreamRead(T_uezDevice aDevice, void *aData, TUInt32 aNumBytes,
        TUInt32* aNumBytesRead, TUInt32 aTimeout) {
    T_uezError error;
    DEVICE_STREAM **p;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **) &p);
    if (error)
        return error;

    return (*p)->Read((void *) p, aData, aNumBytes, aNumBytesRead, aTimeout);
}

/*---------------------------------------------------------------------------*/
T_uezError UEZLEDBankClose(T_uezDevice aDevice)
{
    T_uezError error;
    DEVICE_LEDBank **p;
    
    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **)&p);
    if (error)
        return error;

    return error;
}

/*---------------------------------------------------------------------------*/
T_uezError UEZI2CResetBus(T_uezDevice aDevice)
{
    T_uezError error;
    DEVICE_I2C_BUS **p;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **)&p);
    if (error)
        return error;

    return (*p)->ResetBus((void *)p);
}

/*---------------------------------------------------------------------------*/
T_uezError UEZI2CIsHung(T_uezDevice aDevice, TBool *aBool)
{
    T_uezError error;
    DEVICE_I2C_BUS **p;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **)&p);
    if (error)
        return error;

    return (*p)->IsHung((void *)p, aBool);
}

/*---------------------------------------------------------------------------*/
T_uezError UEZI2CSlaveStart(T_uezDevice aDevice, const T_I2CSlaveSetup *aSetup)
{
    T_uezError error;
    DEVICE_I2C_BUS **p;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **)&p);
    if (error)
        return error;

    return (*p)->SlaveStart((void *)p, aSetup);
}

/*---------------------------------------------------------------------------*/
T_uezError UEZI2CClose(T_uezDevice aDevice)
{
    T_uezError error;
    DEVICE_I2C_BUS **p;

    error = UEZDeviceTableGetWorkspace(aDevice, (T_uezDeviceWorkspace **)&p);
    if (error)
        return error;

    return error;
}