void AudioAmp_8551T_Create(
const char *aName,
T_uezGPIOPortPin aVolumeGPIO,
T_uezGPIOPortPin aModeGPIO,
T_uezGPIOPortPin aVolEnableGPIO,
TInt8 aMaxLevel)
{
T_AudioAmp_8551T_Workspace *p;
UEZDeviceTableRegister(
aName,
(T_uezDeviceInterface *)&AudioAmp_8551T_Interface,
0,
(T_uezDeviceWorkspace **)&p);
UEZGPIOLock(aVolumeGPIO);
p->iVolumeGPIO = aVolumeGPIO;
UEZGPIOLock(aModeGPIO);
p->iModeGPIO = aModeGPIO;
if (aVolEnableGPIO != GPIO_NONE)
UEZGPIOLock(aVolEnableGPIO);
p->iVolEnableGPIO = aVolEnableGPIO;
if(aMaxLevel > HIGH_LEVEL){
p->iMaxLevel = HIGH_LEVEL;
} else {
p->iMaxLevel = aMaxLevel;
}
p->iMinLevel = 0;
}
/*---------------------------------------------------------------------------*
* Routine: UEZGUI_EXP_DK_FullDuplex_RS485_Require
*---------------------------------------------------------------------------*
* Description:
* Setup a full duplex RS485 connection.
*---------------------------------------------------------------------------*/
void UEZGUI_EXP_DK_FullDuplex_RS485_Require(
TUInt32 aWriteBufferSize,
TUInt32 aReadBufferSize)
{
// Need UART A without a stream
UEZPlatform_ExpansionPrimary_UART_A_Require();
// Ensure the drive enable pin is always HIGH
if (GPIO_EXPDK_485DE != GPIO_NONE) {
UEZGPIOSetMux(GPIO_EXPDK_485DE, 0);
UEZGPIOSet(GPIO_EXPDK_485DE);
UEZGPIOOutput(GPIO_EXPDK_485DE);
UEZGPIOLock(GPIO_EXPDK_485DE);
}
// Ensure the receive enable pin is always low
if (GPIO_EXPDK_485RE != GPIO_NONE) {
// Drive enable pin must be LOW
UEZGPIOSetMux(GPIO_EXPDK_485RE, 0);
UEZGPIOClear(GPIO_EXPDK_485RE);
UEZGPIOOutput(GPIO_EXPDK_485RE);
UEZGPIOLock(GPIO_EXPDK_485RE);
}
Serial_Generic_FullDuplex_Stream_Create("EXP_RS485",
PRIMARY_EXPANSION_UART_A, aWriteBufferSize, aReadBufferSize);
}
void RX62N_PinsLock(
const T_uezGPIOPortPin *aPins,
TUInt8 aCount)
{
while (aCount--) {
UEZGPIOLock(aPins[aCount]);
}
}
/*---------------------------------------------------------------------------*
* Routine: uEZPlatformStartup
*---------------------------------------------------------------------------*
* Description:
* When uEZ starts, a special Startup task is created and called.
* This task brings up the all the hardware, reports any problems,
* starts the main task, and then exits.
*---------------------------------------------------------------------------*/
TUInt32 uEZPlatformStartup(T_uezTask aMyTask, void *aParameters)
{
extern T_uezTask G_mainTask;
UEZPlatform_Standard_Require();
SUIInitialize(SIMPLEUI_DOUBLE_SIZED_ICONS, EFalse, EFalse); // SWIM not flipped
// USB Flash drive host mode needed?
#if USB_PORT_B_HOST_DETECT_ENABLED
UEZGPIOLock(GPIO_P0_12);
UEZGPIOSet(GPIO_P0_12); // disable MIC2025
UEZGPIOOutput(GPIO_P0_12);
UEZGPIOInput(GPIO_P0_28);
UEZGPIOSetMux(GPIO_P0_28, 0);
G_usbIsDevice = UEZGPIORead(GPIO_P0_28);
if (G_usbIsDevice) {
// High for a device
UEZPlatform_USBDevice_Require();
} else {
// Low for a host
#if UEZ_ENABLE_USB_HOST_STACK
UEZPlatform_USBFlash_Drive_Require(0);
#endif
UEZGPIOClear(GPIO_P0_12); // enable MIC2025
}
#else
G_usbIsDevice = ETrue;
// USB Device needed?
UEZPlatform_USBDevice_Require();
#endif
#if UEZ_ENABLE_USB_HOST_STACK
// USB Host is required
UEZPlatform_USBFlash_Drive_Require(0);
#endif
// SDCard needed?
UEZPlatform_SDCard_Drive_Require(1);
// Network needed?
#if UEZ_ENABLE_WIRED_NETWORK
UEZPlatform_WiredNetwork0_Require();
#endif
// Create a main task (not running yet)
UEZTaskCreate((T_uezTaskFunction)MainTask, "Main", MAIN_TASK_STACK_SIZE, 0,
UEZ_PRIORITY_NORMAL, &G_mainTask);
// Done with this task, fall out
return 0;
}
void LPC17xx_40xx_IOCON_ConfigPin(
T_uezGPIOPortPin aPortPin,
const T_LPC17xx_40xx_IOCON_ConfigList *aList,
TUInt8 aCount)
{
while (aCount--) {
if (aList->iPortPin == aPortPin) {
UEZGPIOLock(aPortPin);
UEZGPIOControl(aPortPin, GPIO_CONTROL_SET_CONFIG_BITS,
aList->iSetting);
return;
}
aList++;
}
UEZFailureMsg("Bad Pin");
}
/*---------------------------------------------------------------------------*
* Routine: UEZGUI_EXP_DK_USB_Host_Port_B_Detect
*---------------------------------------------------------------------------*
* Description:
* Detect USB Host mode on mini-AB port using OTG adapter ID pin to GND
*---------------------------------------------------------------------------*/
TBool UEZGUI_EXP_DK_USB_Host_Port_B_Detect()
{
TBool IsDevice;
UEZGPIOLock(GPIO_USB_HOST_ENABLE); // P0_12 on LPC1788 uEZGUIs
UEZGPIOSet(GPIO_USB_HOST_ENABLE); // disable MIC2025 power for USB
UEZGPIOOutput(GPIO_USB_HOST_ENABLE);
UEZGPIOInput(GPIO_EXPDK_USBDID);
UEZGPIOSetMux(GPIO_EXPDK_USBDID, 0);
IsDevice = UEZGPIORead(GPIO_EXPDK_USBDID);
if(!IsDevice){
UEZGPIOClear(GPIO_USB_HOST_ENABLE);// enable MIC2025 USB Power
}
return IsDevice;
}
void RX63N_S12AD_Require(TUInt32 channelMask)
{
TUInt8 i;
static const T_uezGPIOPortPin pins[] = {
GPIO_P40, // AN000
GPIO_P41, // AN001
GPIO_P42, // AN002
GPIO_P43, // AN003
GPIO_P44, // AN004
GPIO_P45, // AN005
GPIO_P46, // AN006
GPIO_P47, // AN007
GPIO_PD0, // AN008
GPIO_PD1, // AN009
GPIO_PD2, // AN010
GPIO_PD3, // AN011
GPIO_PD4, // AN012
GPIO_PD5, // AN013
GPIO_P90, // AN014
GPIO_P91, // AN015
GPIO_P92, // AN016
GPIO_P93, // AN017
GPIO_P00, // AN018
GPIO_P01, // AN019
GPIO_P02, // AN020
};
HAL_DEVICE_REQUIRE_ONCE();
HALInterfaceRegister("ADC_S12AD", (T_halInterface *)&RX63N_ADC_S12AD_Interface,
0, 0);
for(i=0; i<21; i++) {
if(channelMask & (1<<i)) {
*G_ADC_PFS[i] = 1; // Set ADC i to Analog Input
UEZGPIOLock(pins[i]);
}
}
}
/*--------------------------------------------------------------------------*/
T_uezError GainSpan_CmdLib_ConfigureForSPI(
const T_GainSpan_CmdLib_SPISettings *aSettings)
{
T_uezError error;
ATLIBGS_MSG_ID_E r;
int i;
G_GSCmdLibSettings = *aSettings;
G_GSSPITemplate.iBitsPerTransfer = 8;
G_GSSPITemplate.iCSPolarity = EFalse; // Falling edge
G_GSSPITemplate.iClockOutPolarity = EFalse; // Falling edge
G_GSSPITemplate.iClockOutPhase = EFalse; // ETrue;
G_GSSPITemplate.iDataMISO = 0;
G_GSSPITemplate.iDataMISO = 0;
G_GSSPITemplate.iNumTransferredIn = 0;
G_GSSPITemplate.iNumTransferredOut = 0;
G_GSSPITemplate.iRate = aSettings->iRate / 1000;
G_GSSPITemplate.iCSGPIOPort = GPIO_TO_HAL_PORT(aSettings->iSPIChipSelect);
G_GSSPITemplate.iCSGPIOBit = GPIO_TO_PIN_BIT(aSettings->iSPIChipSelect);
error = UEZSPIOpen(G_GSCmdLibSettings.iSPIDeviceName, &G_GSSPI);
if (error)
return error;
// Ensure these pins are not configured elsewhere
UEZGPIOLock(G_GSCmdLibSettings.iDataReadyIO);
if (G_GSCmdLibSettings.iSRSTn != GPIO_NONE ){
UEZGPIOLock(G_GSCmdLibSettings.iSRSTn);
UEZGPIOOutput(G_GSCmdLibSettings.iSRSTn); // WIFI_SRSTn
}
UEZGPIOInput(G_GSCmdLibSettings.iDataReadyIO); // WIFI IRQ
if (G_GSCmdLibSettings.iProgramMode != GPIO_NONE ) {
UEZGPIOLock(G_GSCmdLibSettings.iProgramMode);
UEZGPIOClear(G_GSCmdLibSettings.iProgramMode); // WIFI PROGRAM OFF
UEZGPIOOutput(G_GSCmdLibSettings.iProgramMode); // WIFI PROGRAM OFF
}
if (G_GSCmdLibSettings.iSPIMode != GPIO_NONE ) {
UEZGPIOLock(G_GSCmdLibSettings.iSPIMode);
UEZGPIOSet(G_GSCmdLibSettings.iSPIMode); // WIFI_MODE SPI
UEZGPIOOutput(G_GSCmdLibSettings.iSPIMode); // WIFI_MODE SPI
}
UEZTaskDelay(1250);
if (G_GSCmdLibSettings.iSRSTn != GPIO_NONE )
UEZGPIOSet(G_GSCmdLibSettings.iSRSTn); // WIFI_SRSTn
UEZTaskDelay(1000);
// Initialize the GainSpan SPI routines
GainSpan_SPI_Start();
// Flush anything there
AtLibGs_FlushIncomingMessage();
/* Send command to check 5 times for module */
for (i = 0; i < 5; i++){
AtLibGs_FlushIncomingMessage();
r = AtLibGs_Check(GAINSPAN_AT_DEFAULT_TIMEOUT);
if(ATLIBGS_MSG_ID_OK == r){
break;
}
}
if(ATLIBGS_MSG_ID_RESPONSE_TIMEOUT == r){
return UEZ_ERROR_NOT_FOUND;
}
/* Send command to DISABLE echo */
do {
r = AtLibGs_SetEcho(ATLIBGS_DISABLE);
} while (ATLIBGS_MSG_ID_OK != r);
// For now, just report it is not found
if (r != ATLIBGS_MSG_ID_OK)
return UEZ_ERROR_NOT_FOUND;
return UEZ_ERROR_NONE;
}
