/*---------------------------------------------------------------------------*/
int UEZCmdWAVPlay(void *aWorkspace, int argc, char *argv[])
{
T_uezError error;
if (argc == 2) {
UEZWAVConfig(48);
error = UEZWAVPlayFile(argv[1]);
if (error) {
FDICmdPrintf(aWorkspace, "FAIL: Error %d\n", error);
return error;
} else {
// Wait for it to start playing
while (!UEZWAVGetStatus()) {
UEZTaskDelay(1);
}
// Wait for it to end
while (UEZWAVGetStatus()) {
UEZTaskDelay(1);
}
UEZWAVCleanUp();
FDICmdPrintf(aWorkspace, "PASS: OK\n");
}
} else {
FDICmdSendString(aWorkspace,
"FAIL: Incorrect parameters.\nWAVPLAY <wav file>\n");
}
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*/
void MainMenu(void)
{
T_uezDevice lcd;
char line[100];
TUInt32 size;
T_uezDevice flash;
NVSettingsLoad();
// Open the LCD and get the pixel buffer
UEZLCDOpen("LCD", &lcd);
// Setup the LCD, setup the window, and clear the screen
ScreenInit();
//Calibrate();
//UEZQueueCreate(1, sizeof(T_uezInputEvent), &G_tsQueue);
//UEZTSOpen("Touchscreen", &G_ts, &G_tsQueue);
print("Clearing receive area ...\n");
PNFClearArea(IMAGE_ADDR, IMAGE_SIZE);
sprintf(line, "Waiting for image at 0x%08lX ... \n", IMAGE_ADDR);
print(line);
// Wait for an image to appear
JLINK_MODE = 0;
while (JLINK_MODE != 1) {
UEZTaskDelay(10);
}
print("Image received.\n");
print("Determing size ... ");
size = PNFGetSize(IMAGE_ADDR, IMAGE_SIZE);
sprintf(line, "%u bytes\n", size);
print(line);
print("Erasing ...");
UEZFlashOpen("Flash0", &flash);
UEZFlashBlockErase(flash, 0, size);
print("done.\n");
print("Writing ...");
UEZFlashWrite(flash, 0, (void *)IMAGE_ADDR, size);
print("done.\n");
UEZFlashClose(flash);
print("\n** NOR Flash Programming Complete. **\n");
JLINK_MODE = 2;
while (1) {
UEZTaskDelay(10);
}
}
/*---------------------------------------------------------------------------*
* Task: Heartbeat
*---------------------------------------------------------------------------*
* Description:
* Blink heartbeat LED
* Inputs:
* T_uezTask aMyTask -- Handle to this task
* void *aParams -- Parameters. Not used.
* Outputs:
* TUInt32 -- Never returns.
*---------------------------------------------------------------------------*/
TUInt32 Heartbeat(T_uezTask aMyTask, void *aParams)
{
UEZGPIOOutput(GPIO_PD0);
// Blink
for (;;) {
UEZGPIOSet(GPIO_PD0);
UEZTaskDelay(250);
UEZGPIOClear(GPIO_PD0);
UEZTaskDelay(250);
}
return 0;
}
/*---------------------------------------------------------------------------*
* Routine: Open
*---------------------------------------------------------------------------*
* Description:
* Initalizes pins for the audio amp
* turns it on
* sets the level to the default
* Inputs:
* void *aWorkSpace
* Outputs:
* T_uezError -- Error code
*---------------------------------------------------------------------------*/
T_uezError AudioAmp_8551T_Open(void *aWorkSpace)
{
T_AudioAmp_8551T_Workspace *p = (T_AudioAmp_8551T_Workspace *)aWorkSpace;
TUInt8 i, setLevel;
UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE);
p->iNumOpen++;
if (!(p->iIsOn)) {
setLevel = ((p->iLevel * (p->iMaxLevel - p->iMinLevel))/0xFF) + p->iMinLevel;
p->iIsOn = ETrue;
UEZGPIOOutput(p->iModeGPIO);
UEZGPIOSetMux(p->iModeGPIO, 0); // set to GPIO
UEZGPIOClear(p->iModeGPIO); // Turn on the amp
UEZGPIOOutput(p->iVolumeGPIO);
UEZGPIOSetMux(p->iVolumeGPIO, 0); // set to GPIO
for (i = HIGH_LEVEL; i > 0; i--) {
UEZGPIOClear(p->iVolumeGPIO); // set low to go down
UEZGPIOOutput(p->iVolumeGPIO); // set to output
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOSet(p->iVolEnableGPIO);
UEZTaskDelay(1);
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOClear(p->iVolEnableGPIO);
UEZGPIOInput(p->iVolumeGPIO); // set to input
UEZGPIOSetPull(p->iVolumeGPIO, GPIO_PULL_NONE);
UEZTaskDelay(1);
}
for (i = LOW_LEVEL; i < setLevel; i++) {
UEZGPIOSet(p->iVolumeGPIO); // set low to go down
UEZGPIOOutput(p->iVolumeGPIO); // set to output
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOSet(p->iVolEnableGPIO);
UEZTaskDelay(1);
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOClear(p->iVolEnableGPIO);
UEZGPIOInput(p->iVolumeGPIO); // set to input
UEZGPIOSetPull(p->iVolumeGPIO, GPIO_PULL_NONE);
UEZTaskDelay(1);
}
}
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOClear(p->iVolEnableGPIO);
UEZSemaphoreRelease(p->iSem);
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: SetLevel
*---------------------------------------------------------------------------*
* Description:
* Set the gain of the audio amp to the desired level
* Inputs:
* void *aWorkspace
* TUInt8 aLevel --new level to set the amp to
* Outputs:
* T_uezError -- Error code
*---------------------------------------------------------------------------*/
T_uezError AudioAmp_8551T_SetLevel(void *aWorkSpace, TUInt8 aLevel)
{
T_AudioAmp_8551T_Workspace *p = (T_AudioAmp_8551T_Workspace *)aWorkSpace;
TUInt8 i, setLevel, oldLevel;
UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE);
oldLevel = ((((p->iLevel * 100) / (0xFF)) * (p->iMaxLevel - p->iMinLevel))/100) + p->iMinLevel;
p->iLevel = aLevel;
setLevel = ((p->iLevel * (p->iMaxLevel - p->iMinLevel))/0xFF) + p->iMinLevel;
UEZGPIOSetMux(p->iVolumeGPIO, 0); // set to GPIO
if (setLevel != oldLevel) {
if (oldLevel < setLevel) {
for (i = oldLevel; i < setLevel; i++) {
UEZGPIOSet(p->iVolumeGPIO); //set High to go up
UEZGPIOOutput(p->iVolumeGPIO); //set to output
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOSet(p->iVolEnableGPIO);
UEZTaskDelay(1);
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOClear(p->iVolEnableGPIO);
UEZGPIOInput(p->iVolumeGPIO);
UEZGPIOClear(p->iVolumeGPIO);
UEZGPIOSetPull(p->iVolumeGPIO, GPIO_PULL_NONE);
UEZTaskDelay(1);
}
} else {
for (i = oldLevel; i > setLevel; i--) {
UEZGPIOClear(p->iVolumeGPIO); //set low to go down
UEZGPIOOutput(p->iVolumeGPIO); //set to output
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOSet(p->iVolEnableGPIO);
UEZTaskDelay(1);
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOClear(p->iVolEnableGPIO);
UEZGPIOInput(p->iVolumeGPIO);
UEZGPIOSetPull(p->iVolumeGPIO, GPIO_PULL_NONE);
UEZTaskDelay(1);
}
}
p->iLevel = aLevel;
}
if (p->iVolEnableGPIO != GPIO_NONE)
UEZGPIOClear(p->iVolEnableGPIO);
UEZSemaphoreRelease(p->iSem);
return UEZ_ERROR_NONE;
}
static void Host_ResetPort(void *aWorkspace)
{
T_LPC17xx_40xx_USBHost_Workspace *p = (T_LPC17xx_40xx_USBHost_Workspace *)aWorkspace;
UEZTaskDelay(100);
// Apply port reset
*p->iPortStatus |= OR_RH_PORT_PRS;
// Wait for 100 MS after port reset
UEZTaskDelay(100);
// Default max packet size to 8 to ensure compatibility
EDCtrl->Control = (8 << 16);
}
TUInt32 TestVCNL4010Task(T_uezTask aMyTask, void *aParameters)
{
TUInt8 cmd[2];
TUInt8 data[4];
TUInt32 ambient;
TUInt32 proximity;
int count = 0;
// Set Current to 20
cmd[0] = REGISTER_PROX_CURRENT;
cmd[1] = 20; // 20 x 10 = 200 mA, max
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 2, 1000);
for(count = 0; count < 100; count++) {
printf("Reading ... ");
// Request to trigger both ALS and Proximity
cmd[0] = REGISTER_COMMAND;
cmd[1] = 0x18;
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 2, 1000);
do {
printf("?");
// Now read back the status (after writing command index)
cmd[0] = REGISTER_COMMAND;
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 1, 1000);
UEZI2CRead(G_i2cBus, G_i2cAddr, I2C_SPEED, data, 1, 1000);
// Is it ready?
if (data[0] & (COMMAND_MASK_PROX_DATA_READY | COMMAND_MASK_AMBI_DATA_READY))
break;
// Not ready yet, pause and try again in a moment
UEZTaskDelay(10);
} while (1);
// Now read the data
cmd[0] = REGISTER_AMBI_VALUE;
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 1, 1000);
UEZI2CRead(G_i2cBus, G_i2cAddr, I2C_SPEED, data, 4, 1000);
ambient = (data[0] << 8) | data[1];
proximity = (data[2] << 8) | data[3];
printf("Ambient: %04X, Proximity: %04X\n", ambient, proximity);
UEZTaskDelay(100);
}
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: MainMenu
*---------------------------------------------------------------------------*
* Description:
* Present the main menu
*---------------------------------------------------------------------------*/
void MainMenu(void)
{
T_uezDevice lcd;
T_pixelColor *pixels;
// Open the LCD and get the pixel buffer
if (UEZLCDOpen("LCD", &lcd) == UEZ_ERROR_NONE) {
UEZLCDGetFrame(lcd, 0, (void **)&pixels);
#if (!FAsT_STARTUP)
// Clear the screen
TitleScreen();
//while(1);
PlayAudio(523, 100);
PlayAudio(659, 100);
PlayAudio(783, 100);
PlayAudio(1046, 100);
PlayAudio(783, 100);
PlayAudio(659, 100);
PlayAudio(523, 100);
// Force calibration?
Calibrate(CalibrateTestIfTouchscreenHeld());
UEZTaskDelay(1000);
#else
UEZLCDBacklight(lcd, 255);
Calibrate(FALSE);
#endif
AppMenu(&mainmenu);
UEZLCDClose(lcd);
}
}
TUInt32 AccelerometerMonitor(T_uezTask aMyTask, void *aParams)
{
T_uezDevice Accel;
double x, y, z;
int i;
AccelerometerReading ar;
if (UEZAccelerometerOpen("Accel0", &Accel) == UEZ_ERROR_NONE) {
while (1) {
// The device opened properly
x = y = z = 0;
for (i=0; i<8; i++) {
if (UEZAccelerometerReadXYZ(Accel, &ar, 10) != UEZ_ERROR_NONE) {
UEZFailureMsg("Accelerometer failed to read!");
break;
}
x += ar.iX;
y += ar.iY;
z += ar.iZ;
}
// Convert from signed 15.16 fixed format to doubles over 8 samples
// The value is in g's. For example, the x, y, z is
// (0.0, 0.0, -1.0) when at rest on a table.
x /= 65536.0 * 8;
y /= 65536.0 * 8;
z /= 65536.0 * 8;
DataLogXYZ(x, y, z);
// Sleep before next reading
UEZTaskDelay(1000);
}
}
return 0;
}
/*---------------------------------------------------------------------------*
* Routine: LCD_UMSH_8596MD_20T_On
*---------------------------------------------------------------------------*
* Description:
* Turns on the LCD display.
* Inputs:
* void *aW -- Workspace
* Outputs:
* T_uezError -- If successful, returns UEZ_ERROR_NONE.
*---------------------------------------------------------------------------*/
T_uezError LCD_UMSH_8596MD_20T_On(void *aW)
{
// Turn back on to the remembered level
T_UMSH_8596MD_20TWorkspace *p = (T_UMSH_8596MD_20TWorkspace *)aW;
#if UEZ_LCD_POWER_GPIO_PIN
HAL_GPIOPort **p_gpio = p->iPowerGPIOPort;
#endif
#if UEZ_LCD_POWER_GPIO_PIN
if (p_gpio) {
(*p_gpio)->SetOutputMode(p_gpio, 1UL<<UEZ_LCD_POWER_GPIO_PIN);
(*p_gpio)->SetMux(p_gpio, UEZ_LCD_POWER_GPIO_PIN, 0); // set to GPIO
(*p_gpio)->Clear(p_gpio, 1UL<<UEZ_LCD_POWER_GPIO_PIN);
}
#endif
(*p->iLCDController)->On(p->iLCDController);
UEZTaskDelay(200);//added delay to match timing in datasheet
if (p->iBacklight)
(*p->iBacklight)->On(p->iBacklight);
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: LCD_UMSH_8596MD_20T_Off
*---------------------------------------------------------------------------*
* Description:
* Turns off the LCD display.
* Inputs:
* void *aW -- Workspace
* Outputs:
* T_uezError -- If successful, returns UEZ_ERROR_NONE.
*---------------------------------------------------------------------------*/
T_uezError LCD_UMSH_8596MD_20T_Off(void *aW)
{
// Turn off, but don't remember the level
T_UMSH_8596MD_20TWorkspace *p = (T_UMSH_8596MD_20TWorkspace *)aW;
#if UEZ_LCD_POWER_GPIO_PIN
HAL_GPIOPort **p_gpio = p->iPowerGPIOPort;
#endif
//changed order and added delay to match timing diagram in datasheet.
if (p->iBacklight)
(*p->iBacklight)->Off(p->iBacklight);
UEZTaskDelay(200);
#if UEZ_LCD_POWER_GPIO_PIN
if (p_gpio) {
(*p_gpio)->SetOutputMode(p_gpio, 1UL<<UEZ_LCD_POWER_GPIO_PIN);
(*p_gpio)->SetMux(p_gpio, UEZ_LCD_POWER_GPIO_PIN, 0); // set to GPIO
(*p_gpio)->Set(p_gpio, 1UL<<UEZ_LCD_POWER_GPIO_PIN);
}
#endif
(*p->iLCDController)->Off(p->iLCDController);
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: LCD_LQ104V1DG28_Open
*---------------------------------------------------------------------------*
* Description:
* Start the LCD screen. If this is the first open, initialize the
* screen.
* Inputs:
* void *aW -- Workspace
* Outputs:
* T_uezError -- If the device is opened, returns
* UEZ_ERROR_NONE.
*---------------------------------------------------------------------------*/
static T_uezError LCD_LQ104V1DG28_Open(void *aW)
{
T_LQ104V1DG28Workspace *p = (T_LQ104V1DG28Workspace *)aW;
HAL_LCDController **plcdc;
T_uezError error = UEZ_ERROR_NONE;
p->aNumOpen++;
if (p->aNumOpen == 1) {
plcdc = p->iLCDController;
if (!error) {
switch (p->iConfiguration->iColorDepth) {
case UEZLCD_COLOR_DEPTH_8_BIT:
LCD_LQ104V1DG28_settings = LCD_LQ104V1DG28_params8bit;
break;
default:
case UEZLCD_COLOR_DEPTH_16_BIT:
LCD_LQ104V1DG28_settings = LCD_LQ104V1DG28_params16bit;
break;
case UEZLCD_COLOR_DEPTH_I15_BIT:
LCD_LQ104V1DG28_settings = LCD_LQ104V1DG28_paramsI15bit;
break;
}
LCD_LQ104V1DG28_settings.iBaseAddress = p->iBaseAddress;
// start DOTCLK immediately
error = (*plcdc)->Configure(plcdc, &LCD_LQ104V1DG28_settings);
// start HSYNC and VSYNC (same as UEZLCDOn(lcd))
(*p->iLCDController)->On(p->iLCDController);
UEZTaskDelay(10); // delay before turning backlight on, min 10 frame
(*p->iBacklight)->On(p->iBacklight); // turn backlight on
}
}
return error;
}
/*-------------------------------------------------------------------------*
* Prototypes:
*-------------------------------------------------------------------------*/
TUInt32 TestVCNL4010FCT(const char *aI2CName, TUInt8 aI2CAddr,
TUInt32 * const ambient, TUInt32 * const proximity)
{
TUInt8 cmd[2];
TUInt8 data[4];
UEZI2COpen(aI2CName, &G_i2cBus);
G_i2cAddr = aI2CAddr;
// Set Current to 20
cmd[0] = REGISTER_PROX_CURRENT;
cmd[1] = 20; // 20 x 10 = 200 mA, max
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 2, 1000);
printf("Reading ... ");
// Request to trigger both ALS and Proximity
cmd[0] = REGISTER_COMMAND;
cmd[1] = 0x18;
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 2, 1000);
do {
printf("?");
// Now read back the status (after writing command index)
cmd[0] = REGISTER_COMMAND;
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 1, 1000);
UEZI2CRead(G_i2cBus, G_i2cAddr, I2C_SPEED, data, 1, 1000);
// Is it ready?
if (data[0] & (COMMAND_MASK_PROX_DATA_READY | COMMAND_MASK_AMBI_DATA_READY))
break;
// Not ready yet, pause and try again in a moment
UEZTaskDelay(10);
} while (1);
// Now read the data
cmd[0] = REGISTER_AMBI_VALUE;
UEZI2CWrite(G_i2cBus, G_i2cAddr, I2C_SPEED, cmd, 1, 1000);
UEZI2CRead(G_i2cBus, G_i2cAddr, I2C_SPEED, data, 4, 1000);
*ambient = (data[0] << 8) | data[1];
*proximity = (data[2] << 8) | data[3];
printf("Ambient: %04X, Proximity: %04X\n", *ambient, *proximity);
UEZTaskDelay(100);
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: IExitProgramMode
*---------------------------------------------------------------------------*
* Description:
* Exit programming mode
* Inputs:
* T_Flash_S29GL064N90_Workspace *p -- Workspace
*---------------------------------------------------------------------------*/
static void IExitProgramMode(T_Flash_Renesas_RX63N_Workspace *p)
{
if (p->iIsProgramMode) {
// If we are in programming mode, exit it
UEZTaskDelay(1);
p->iIsProgramMode = EFalse;
}
}
/*---------------------------------------------------------------------------*/
static TUInt32 Heartbeat(T_uezTask aMyTask, void *aParams)
{
HAL_GPIOPort **p_gpio;
const TUInt32 pin = 13;
TBool run = ETrue;
HALInterfaceFind("GPIO1", (T_halWorkspace **)&p_gpio);
(*p_gpio)->SetOutputMode(p_gpio, 1<<pin);
(*p_gpio)->SetMux(p_gpio, pin, 0); // set to GPIO
// Blink
while (run) {
(*p_gpio)->Set(p_gpio, 1<<pin);
UEZTaskDelay(250);
(*p_gpio)->Clear(p_gpio, 1<<pin);
UEZTaskDelay(250);
}
return 0;
}
TUInt32 NetworkStartup(T_uezTask aMyTask, void *aParams)
{
T_uezError error = UEZ_ERROR_NONE;
#if UEZ_ENABLE_WIRED_NETWORK
T_uezDevice wired_network;
#endif
#if UEZ_ENABLE_WIRED_NETWORK
// ----------------------------------------------------------------------
// Bring up the Wired Network
// ----------------------------------------------------------------------
printf("Bringing up wired network: Start\n");
// First, get the Wireless Network connection
UEZPlatform_WiredNetwork0_Require();
error = UEZNetworkOpen("WiredNetwork0", &wired_network);
if (error)
UEZFailureMsg("NetworkStartup: Wired failed to start");
// Configure the type of network desired
INetworkConfigureWiredConnection(wired_network);
// Bring up the infrastructure
error = UEZNetworkInfrastructureBringUp(wired_network);
// If no problem bringing up the infrastructure, join the network
if (!error)
error = UEZNetworkJoin(wired_network, "lwIP", 0, 5000);
// Let the last messages through (debug only)
UEZTaskDelay(1000);
// Report the result
if (error) {
printf("Bringing up wired network: **FAILED** (error = %d)\n", error);
} else {
printf("Bringing up wired network: Done\n");
}
#endif
#if UEZ_ENABLE_TCPIP_STACK
printf("Webserver starting\n");
error = BasicWebStart(wired_network);
if (error) {
printf("Problem starting BasicWeb! (Error=%d)\n", error);
} else {
printf("BasicWeb started\n");
}
#endif
return 0;
}
/*---------------------------------------------------------------------------*
* Routine: LCD_LMIX0560NTN53V1_On
*---------------------------------------------------------------------------*
* Description:
* Turns on the LCD display.
* Inputs:
* void *aW -- Workspace
* Outputs:
* T_uezError -- If successful, returns UEZ_ERROR_NONE.
*---------------------------------------------------------------------------*/
T_uezError LCD_LMIX0560NTN53V1_On(void *aW)
{
// Turn back on to the remembered level
T_LMIX0560NTN53V1Workspace *p = (T_LMIX0560NTN53V1Workspace *)aW;
(*p->iLCDController)->On(p->iLCDController);
UEZTaskDelay(50);
if (p->iBacklight)
(*p->iBacklight)->On(p->iBacklight);
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: ST_Accelo_LIS3LV02DQ_I2C_ReadXYZ
*---------------------------------------------------------------------------*
* Description:
* Try to get the XYZ reading of the accelerometer
* Inputs:
* void *aW -- Workspace
* AccelerometerReading *aReading -- Place to store reading
* TUInt32 aTimeout -- Time to wait until reading is ready
* Outputs:
* T_uezError -- Error code, UEZ_ERROR_TIMEOUT if no
* reading.
*---------------------------------------------------------------------------*/
T_uezError ST_Accelo_LIS3LV02DQ_I2C_ReadXYZ(
void *aWorkspace,
AccelerometerReading *aReading,
TUInt32 aTimeout)
{
TUInt32 i;
TUInt8 status;
T_uezError error;
T_ST_Accelo_LIS3LV02DQ_I2C_Workspace *p =
(T_ST_Accelo_LIS3LV02DQ_I2C_Workspace *)aWorkspace;
static TUInt8 accdata[18];
aReading->iX = 0;
aReading->iY = 0;
aReading->iZ = 0;
// Allow only one transfer at a time
error = UEZSemaphoreGrab(p->iSem, aTimeout);
if (error)
return error;
for (i=0; i<10; i++) { // try 10 times
memset(accdata, 0xCC, sizeof(accdata));
error = IReadData(p, accdata, 0x27, 7, 100);
status = accdata[0];
if (status & (1<<3)) {
aReading->iX = ICalcG(accdata[2], accdata[1]);
aReading->iY = ICalcG(accdata[4], accdata[3]);
aReading->iZ = ICalcG(accdata[6], accdata[5]);
p->iLastReading = *aReading;
break; // break if successful
}
UEZTaskDelay(2);
/*
Array Contents After Read
accdata[0] - STATUS_REG (0x27)
accdata[1] - OUTX_L (0x28)
accdata[2] - OUTX_H (0x29)
accdata[3] - OUTY_L (0x2A)
accdata[4] - OUTY_H (0x2B)
accdata[5] - OUTZ_L (0x2C)
accdata[6] - OUTZ_H (0x2D)
*/
}
if (i==10) {
*aReading = p->iLastReading;
}
UEZSemaphoreRelease(p->iSem);
return error;
}
TBool TestModeSendCmd(TUInt32 aCmd)
{
// Go into test mode (if not already running)
G_mmTestMode = ETrue;
while (!G_mmTestModeRunning) {
UEZTaskDelay(10);
}
// Check if we are running and send command
if (G_mmTestModeRunning) {
if (UEZQueueSend(G_mmTestModeQueue, &aCmd, UEZ_TIMEOUT_INFINITE) != UEZ_ERROR_NONE)
return EFalse;
return ETrue;
}
return EFalse;
}
/*---------------------------------------------------------------------------*
* Routine: PlayAudio
*---------------------------------------------------------------------------*
* Description:
* Play a tone for the given length, staying here until done.
* Inptus:
* TUInt32 aHz -- Tone in Hz
* TUInt32 aMS -- Duration of tone
*---------------------------------------------------------------------------*/
void PlayAudio(TUInt32 aHz, TUInt32 aMS)
{
#if OPTION_USE_GPIO_LINES_FOR_AUDIO
static HAL_GPIOPort **p_gpio0;
TUInt32 n;
TUInt32 start = UEZTickCounterGet();
TUInt32 count;
HALInterfaceFind("GPIO0", (T_halWorkspace **)&p_gpio0);
(*p_gpio0)->SetOutputMode(p_gpio0, (1<<26));
// Wait for the parameters to be ready
n = (G_subTickCount*1000/2)/aHz;
taskDISABLE_INTERRUPTS();
G_dummyCounter = 0;
// Wait for first tick count
while ((T1IR&2)==0)
{}
while (aMS--) {
T1IR = 2;
while (!(T1IR & 2)) {
count = n;
while (count--)
{ G_dummyCounter++; }
(*p_gpio0)->Clear(p_gpio0, (1<<26));
count = n;
while (count--)
{ G_dummyCounter++; }
(*p_gpio0)->Set(p_gpio0, (1<<26));
}
}
taskENABLE_INTERRUPTS();
#else
if (!G_tg)
CalibrateAudioTiming();
//PWMAudio(aHz, (aMS+10)/10, 0);
if (G_tg)
UEZToneGeneratorPlayTone(
G_tg,
TONE_GENERATOR_HZ(aHz),
aMS);
else
UEZTaskDelay(aMS);
#endif
}
/*---------------------------------------------------------------------------*/
void ScreenOn(void)
{
T_uezDevice lcd;
int i;
UEZLCDOpen("LCD", &lcd);
if (!G_screenOn) {
UEZLCDBacklight(lcd, 0);
UEZLCDOn(lcd);
for (i = 0; i < 255; i++) {
UEZLCDBacklight(lcd, i);
UEZTaskDelay(2);
}
G_screenOn = ETrue;
}
UEZLCDClose(lcd);
}
/*---------------------------------------------------------------------------*
* Routine: EEPROM_NXP_LPC17xx_40xx_Write
*---------------------------------------------------------------------------*
* Description:
* Write bytes into the EEPROM
* Inputs:
* void *aW -- Workspace
* TUInt32 aAddress -- Base address into device to write
* TUInt8 *aBuffer -- Pointer to buffer of data
* TUInt32 aNumBytes -- Number of bytes to write
* Outputs:
* T_uezError -- Error code
*---------------------------------------------------------------------------*/
T_uezError EEPROM_NXP_LPC17xx_40xx_Write(
void *aWorkspace,
TUInt32 aAddress,
TUInt8 *aBuffer,
TUInt32 aNumBytes)
{
T_EEPROM_NXP_LPC17xx_40xx_Workspace *p = (T_EEPROM_NXP_LPC17xx_40xx_Workspace *)aWorkspace;
T_uezError error = UEZ_ERROR_NONE;
TUInt32 size = aNumBytes;
TUInt32 len;
const TUInt32 pageSize = LPC17xx_40xx_EEPROM_PAGE_SIZE;
TUInt32 addr;
// Allow only one transfer at a time
UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE);
if (!p->iInitialized)
IInitialize(p);
while (size) {
// Determine number of bytes remaining in this page
len = pageSize-((aAddress+pageSize)&(pageSize-1));
// Clip to the remaining number of bytes
if (len > size)
len = size;
addr = aAddress & ~(LPC17xx_40xx_EEPROM_PAGE_SIZE-1);
// Read
IReadPage(p, addr, p->iPage, 0);
// Modify
memcpy(p->iPage + (aAddress & (LPC17xx_40xx_EEPROM_PAGE_SIZE-1)), aBuffer, len);
// Write
IWritePage(p, addr, p->iPage, 0);
// Wait the appropriate amount of time
UEZTaskDelay(p->iConfig.iWriteTime);
aAddress += len;
size -= len;
aBuffer += len;
}
UEZSemaphoreRelease(p->iSem);
return error;
}
/*---------------------------------------------------------------------------*
* Routine: MainMenu
*---------------------------------------------------------------------------*
* Description:
* Present the main menu
*---------------------------------------------------------------------------*/
void MainMenu(void)
{
T_uezDevice lcd;
T_pixelColor *pixels;
// Open the LCD and get the pixel buffer
if (UEZLCDOpen("LCD", &lcd) == UEZ_ERROR_NONE) {
UEZLCDGetFrame(lcd, 0, (void **)&pixels);
#if (!FAsT_STARTUP)
// Clear the screen
TitleScreen();
//while(1);
PlayAudio(523, 100);
PlayAudio(659, 100);
PlayAudio(783, 100);
PlayAudio(1046, 100);
PlayAudio(783, 100);
PlayAudio(659, 100);
PlayAudio(523, 100);
// Force calibration?
Calibrate(CalibrateTestIfTouchscreenHeld());
UEZTaskDelay(1000);
#else
UEZLCDBacklight(lcd, 255);
Calibrate(FALSE);
#endif
// Set the screen saver icon
BouncingLogoSS_Setup(
(TUInt8 *)G_uEZLogo,
UEZ_ICON_WIDTH,
UEZ_ICON_HEIGHT,
DISPLAY_WIDTH,
DISPLAY_HEIGHT);
AppMenu(&mainmenu);
UEZLCDClose(lcd);
}
}
/*---------------------------------------------------------------------------*/
int MainTask(void)
{
// Output a start up banner
printf("\f" PROJECT_NAME " " VERSION_AS_TEXT "\n\n");
// Start up the heart beat of the LED
UEZTaskCreate(Heartbeat, "Heart", 64, (void *)0, UEZ_PRIORITY_NORMAL, 0);
// Load any non-volatile settings from the data flash.
NVSettingsInit();
// Load the settings from non-volatile memory
if (NVSettingsLoad() == UEZ_ERROR_CHECKSUM_BAD) {
printf("EEPROM Settings\n");
NVSettingsInit();
NVSettingsSave();
}
// Setup the glyph API to the LCD and draw the title screen.
GlyphOpen(&G_glyphLCD, 0);
IDrawTitle();
// Setup any additional misc. tasks (such as the heartbeat task)
SetupTasks();
// Play startup tones
PlayAudio(523, 100);
PlayAudio(659, 100);
PlayAudio(783, 100);
PlayAudio(1046, 100);
PlayAudio(783, 100);
PlayAudio(659, 100);
PlayAudio(523, 100);
// Wait in an infinite loop.
while(1) {
UEZTaskDelay(10000);
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void IUEZTSMonitorTouchscreensTask(T_uezTask aMyTask, void *aParams)
{
T_tsDevice *p;
T_tsQueue *pq;
T_uezTSReading reading;
T_uezInputEvent inputEvent;
for (;;) {
IUEZTSGrab();
p = G_tsDevices;
while (p) {
if (UEZTSGetReading(p->iDevice, &reading) == UEZ_ERROR_NONE) {
if(reading.iFlags & TSFLAG_PEN_DOWN) {
UEZLCDScreensaverWake();
if(UEZLCDScreensaverIsActive())
G_WaitForRelease = ETrue;
}
if(G_WaitForRelease) {
if(!(reading.iFlags & TSFLAG_PEN_DOWN)) {
// if the pen is released, stop waiting
G_WaitForRelease = EFalse;
}
} else {
// Apply the reading to all the queues (as last reported)
for (pq = p->iQueueList; pq; pq=pq->iNext) {
// Send it on the queue.
inputEvent = IConvertTSReadingToInputEvent(&reading);
UEZQueueSend(pq->iQueue, &inputEvent, 0);
}
}
}
p = p->iNext;
}
IUEZTSRelease();
UEZTaskDelay(10);
}
}
/*---------------------------------------------------------------------------*
* Task: main
*---------------------------------------------------------------------------*
* Description:
* In the uEZ system, main() is a task. Do not exit this task
* unless you want to the board to reset. This function should
* setup the system and then run the main loop of the program.
* Outputs:
* int -- Output error code
*---------------------------------------------------------------------------*/
int MainTask(void)
{
printf("\f" PROJECT_NAME " " VERSION_AS_TEXT "\n\n"); // clear serial screen and put up banner
// Start up the heart beat of the LED
UEZTaskCreate(Heartbeat, "Heart", 64, (void *)0, UEZ_PRIORITY_NORMAL, 0);
NVSettingsInit();
// Load the settings from non-volatile memory
if (NVSettingsLoad() == UEZ_ERROR_CHECKSUM_BAD) {
printf("EEPROM Settings\n");
NVSettingsInit();
NVSettingsSave();
}
// Delete old log file
UEZFileDelete("0:/ACCELLOG.TXT");
// Setup any additional misc. tasks (such as the heartbeat task)
SetupTasks();
GlyphOpen(&G_glyphLCD, 0);
IDrawTitle();
// Play tones
PlayAudio(523, 100);
PlayAudio(659, 100);
PlayAudio(783, 100);
PlayAudio(1046, 100);
PlayAudio(783, 100);
PlayAudio(659, 100);
PlayAudio(523, 100);
while(1) {
UEZTaskDelay(500);
}
return 0;
}
/*---------------------------------------------------------------------------*
* Routine: TS_EXC7200_Configure
*---------------------------------------------------------------------------*
* Description:
* The SPI bus and GPIO device are being declared.
* Inputs:
* void *aW -- Particular SPI workspace
* Outputs:
* T_uezError -- Error code
*---------------------------------------------------------------------------*/
T_uezError TS_EXC7200_Configure(T_uezDeviceWorkspace *aW)
{
T_EXC7200Workspace *p = (T_EXC7200Workspace *)aW;
UEZSemaphoreGrab(p->iSemWaitForTouch, 0);
UEZGPIOSetMux(p->iResetPin, 0);//Set to GPIO
UEZGPIOOutput(p->iResetPin);
UEZGPIOClear(p->iResetPin);
UEZTaskDelay(1);
UEZGPIOConfigureInterruptCallback(
UEZ_GPIO_PORT_FROM_PORT_PIN(p->iInteruptPin),
TS_EXC7200_InterruptISR,
p);
UEZGPIOEnableIRQ(p->iInteruptPin, GPIO_INTERRUPT_FALLING_EDGE);
UEZGPIOSet(p->iResetPin);
T_uezDevice i2c;
I2C_Request request;
T_uezError error;
TUInt8 dataIn[10];
TUInt8 dataOut[10] = { 0x03, 0x06, 0x0A, 0x04, 0x36, 0x3f, 0x01, 9, 0, 0};
request.iAddr = EXC7200_I2C_ADDRESS;
request.iSpeed = EXC7200_I2C_SPEED;
request.iReadData = dataIn;
request.iReadLength = 10;
request.iWriteData = dataOut;
request.iWriteLength = 10;
UEZI2COpen(p->iI2CBus, &i2c);
error = UEZI2CTransaction(i2c, &request);
return UEZ_ERROR_NONE;
}
/*---------------------------------------------------------------------------*
* Routine: DR_Save
*---------------------------------------------------------------------------*
* Description:
* Save the currently shown image to the flash drive.
* Inputs:
* const T_choice *aChoice -- Choice object selected for this action.
*---------------------------------------------------------------------------*/
static void DR_Save(const T_choice *aChoice)
{
T_uezError error;
T_uezError errorUSB, errorSD;
T_uezFile file;
INT_32 winX, winY;
T_pixelColor *raster;
TUInt32 num;
TUInt16 x, y;
// Draw line around choice while saving
swim_set_fill_transparent(&G_drWin, 1);
swim_set_pen_color(&G_drWin, YELLOW);
swim_put_box(
&G_drWin,
aChoice->iLeft,
aChoice->iTop,
aChoice->iRight,
aChoice->iBottom);
// Try to save to the USB drive
error = errorUSB = UEZFileOpen("0:IMAGE.RAW", FILE_FLAG_WRITE, &file);
// If an error, try to save to the SD Card
if (error != UEZ_ERROR_NONE)
error = errorSD = UEZFileOpen("1:IMAGE.RAW", FILE_FLAG_WRITE, &file);
else
errorSD = UEZ_ERROR_UNKNOWN;
// Any errors?
if (error == UEZ_ERROR_NONE) {
raster = (T_pixelColor *)LOAD_SPACE;
for (y=0; y<DR_IMAGE_HEIGHT; y++) {
for (x=0; x<DR_IMAGE_WIDTH; x++) {
winX = x + DR_IMAGE_LEFT+1;
winY = y + DR_IMAGE_TOP+1;
swim_get_physical_xy(&G_drWin, &winX, &winY);
swim_driver_get_raster(&G_drWin, winX, winY, (COLOR_T *)raster, 1); // get pixel color
raster++;
}
}
// Save image
error = UEZFileWrite(
file,
LOAD_SPACE,
DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor),
&num);
if ((error != UEZ_ERROR_NONE) &&
(num != DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor))) {
BeepError();
}
UEZFileClose(file);
} else {
// Had an error, report it
SUICopyFast32(FRAME(1), FRAME(0), FRAME_SIZE);
BeepError();
swim_set_fill_transparent(&G_drWin, 0);
swim_set_fill_color(&G_drWin, BLACK);
swim_set_pen_color(&G_drWin, YELLOW);
swim_put_box(
&G_drWin,
DR_IMAGE_LEFT,
DR_IMAGE_TOP,
DR_IMAGE_RIGHT,
DR_IMAGE_TOP+16);
if (errorUSB == UEZ_ERROR_NOT_FOUND) {
if (errorSD == UEZ_ERROR_NOT_READY) {
swim_put_text_xy(
&G_drWin,
"Could not write image to USB Drive",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else if (errorSD == UEZ_ERROR_NOT_FOUND) {
swim_put_text_xy(
&G_drWin,
"Could not write to USB Drive or SD Card",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else {
swim_put_text_xy(
&G_drWin,
"Could not write to USB Drive",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
}
} else if (errorUSB == UEZ_ERROR_NOT_READY) {
if (errorSD == UEZ_ERROR_NOT_READY) {
swim_put_text_xy(
&G_drWin,
"No USB Drive or SDCard found!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else if (errorSD == UEZ_ERROR_NOT_FOUND) {
swim_put_text_xy(
&G_drWin,
"Could not write to SD Card!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else {
swim_put_text_xy(
&G_drWin,
"Could not write to SD Card!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
}
} else {
swim_put_text_xy(
&G_drWin,
"Write error!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
}
swim_set_fill_transparent(&G_drWin, 1);
UEZTaskDelay(2000);
SUICopyFast32(FRAME(0), FRAME(1), FRAME_SIZE);
}
swim_set_fill_transparent(&G_drWin, 1);
swim_set_pen_color(&G_drWin, BLACK);
swim_put_box(
&G_drWin,
aChoice->iLeft,
aChoice->iTop,
aChoice->iRight,
aChoice->iBottom);
}
/*---------------------------------------------------------------------------*
* Routine: DR_Load
*---------------------------------------------------------------------------*
* Description:
* Load an image from the flash drive and show.
* Inputs:
* const T_choice *aChoice -- Choice object selected for this action.
*---------------------------------------------------------------------------*/
static void DR_Load(const T_choice *aChoice)
{
T_uezError error;
T_uezError errorUSB, errorSD;
T_uezFile file;
INT_32 winX, winY;
TUInt32 num;
TUInt16 x, y;
// Draw line around choice while loading
swim_set_fill_transparent(&G_drWin, 1);
swim_set_pen_color(&G_drWin, YELLOW);
swim_put_box(
&G_drWin,
aChoice->iLeft,
aChoice->iTop,
aChoice->iRight,
aChoice->iBottom);
// Try to load from the USB drive
error = errorUSB = UEZFileOpen("0:IMAGE.RAW", FILE_FLAG_READ_ONLY, &file);
// If an error, try to load from the SD Card
if (error != UEZ_ERROR_NONE)
error = errorSD = UEZFileOpen("1:IMAGE.RAW", FILE_FLAG_READ_ONLY, &file);
else
errorSD = UEZ_ERROR_UNKNOWN;
// Continue if no errors
if (error == UEZ_ERROR_NONE) {
error = UEZFileRead(
file,
LOAD_SPACE,
DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor),
&num);
UEZFileClose(file);
if ((error != UEZ_ERROR_NONE) &&
(num != DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor))) {
BeepError();
} else {
T_pixelColor *raster = (T_pixelColor *)LOAD_SPACE;
for (y=0; y<DR_IMAGE_HEIGHT; y++) {
for (x=0; x<DR_IMAGE_WIDTH; x++) {
winX = x + DR_IMAGE_LEFT+1;
winY = y + DR_IMAGE_TOP+1;
swim_get_physical_xy(&G_drWin, &winX, &winY);
swim_driver_put_pixel(&G_drWin, winX, winY, raster[x]);
}
raster += DR_IMAGE_WIDTH;
}
}
}
if (error) {
// Had an error, report it
SUICopyFast32(FRAME(1), FRAME(0), FRAME_SIZE);
BeepError();
swim_set_fill_transparent(&G_drWin, 0);
swim_set_fill_color(&G_drWin, BLACK);
swim_set_pen_color(&G_drWin, YELLOW);
swim_put_box(
&G_drWin,
DR_IMAGE_LEFT,
DR_IMAGE_TOP,
DR_IMAGE_RIGHT,
DR_IMAGE_TOP+16);
if (errorUSB == UEZ_ERROR_NOT_FOUND) {
if (errorSD == UEZ_ERROR_NOT_READY) {
swim_put_text_xy(
&G_drWin,
"Image file not found on USB Drive!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else if (errorSD == UEZ_ERROR_NOT_FOUND) {
swim_put_text_xy(
&G_drWin,
#if UEZ_DEFAULT_LCD_RES_QVGA
// Shorter string on QVGA screens
"Image file not found on USB or SD Card!",
#else
"Image file not found on USB Drive or SD Card!",
#endif
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else {
swim_put_text_xy(
&G_drWin,
"Image file not found on USB Drive!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
}
} else if (errorUSB == UEZ_ERROR_NOT_READY) {
if (errorSD == UEZ_ERROR_NOT_READY) {
swim_put_text_xy(
&G_drWin,
"No USB Drive or SD Card found!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else if (errorSD == UEZ_ERROR_NOT_FOUND) {
swim_put_text_xy(
&G_drWin,
"Image file not found on SD Card!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
} else {
swim_put_text_xy(
&G_drWin,
"No USB Drive or SD Card found!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
}
} else {
swim_put_text_xy(
&G_drWin,
"Read error!",
DR_IMAGE_LEFT+2,
DR_IMAGE_TOP+2);
}
swim_set_fill_transparent(&G_drWin, 1);
UEZTaskDelay(2000);
SUICopyFast32(FRAME(0), FRAME(1), FRAME_SIZE);
}
swim_set_fill_transparent(&G_drWin, 1);
swim_set_pen_color(&G_drWin, BLACK);
swim_put_box(
&G_drWin,
aChoice->iLeft,
aChoice->iTop,
aChoice->iRight,
aChoice->iBottom);
}
/*********************************************************************
*
* emWin
*
* Function description:
* emWin demo application
*
*/
void emWin(const T_choice *aChoice) {
T_uezDevice hLCD;
U32 FrameBufferSize;
T_uezTask hTouchTask;
(void)aChoice;
FrameBufferSize = UEZ_LCD_DISPLAY_WIDTH * UEZ_LCD_DISPLAY_HEIGHT * GUI_NUM_VIRTUAL_DISPLAYS * GUI_PIXEL_WIDTH;
GUI_pMem = (U32*)(GUI_VRAM_BASE_ADDR + FrameBufferSize);
GUI_MemSize = (GUI_VRAM_SIZE - FrameBufferSize);
memset((void*)GUI_VRAM_BASE_ADDR, 0, GUI_MemSize);//FrameBufferSize);
//
// Check that frame buffer memory fits into VRAM memory and we have empty memory left
//
if (GUI_VRAM_SIZE <= FrameBufferSize) {
return; // Error, not enough memory
}
//
// Assign memory left to emWin memory
//
//GUI_pMem = (U32*)(GUI_VRAM_BASE_ADDR + FrameBufferSize);
//GUI_MemSize = (GUI_VRAM_SIZE - FrameBufferSize);
//
// emWin startup
//
#if EMWIN_LOAD_ONCE
if(G_emWinLoaded == EFalse)
{
WM_SetCreateFlags(WM_CF_MEMDEV); // Enable memory devices
GUI_Init();
G_emWinLoaded = ETrue;
}
#else
WM_SetCreateFlags(WM_CF_MEMDEV); // Enable memory devices
GUI_Init();
#endif
//
// Open the LCD
//
if (UEZLCDOpen("LCD", &hLCD) == UEZ_ERROR_NONE) {
//
// Create touch screen queue
//
if (UEZQueueCreate(1, sizeof(T_uezInputEvent), &_hTSQueue) == UEZ_ERROR_NONE) {
//
// Open touch screen
//
if (UEZTSOpen("Touchscreen", &_hTouchScreen, &_hTSQueue) == UEZ_ERROR_NONE) {
//
// Create touch task
//
if (UEZTaskCreate((T_uezTaskFunction)_TouchTask, "TouchTask", 1024, 0, UEZ_PRIORITY_VERY_HIGH, &hTouchTask) == UEZ_ERROR_NONE) {
//
// emWin application
//
GUIDEMO_Main();
_RequestExit = 1;
while (_RequestExit == 1) {
UEZTaskDelay(1); // Wait for touch task to terminate
}
}
//
// Close touch screen
//
UEZTSClose(_hTouchScreen, _hTSQueue);
}
UEZQueueDelete(_hTSQueue);
}
//
// Close the LCD
//
UEZLCDClose(hLCD);
}
//
// emWin cleanup
//
#if !EMWIN_LOAD_ONCE
GUI_Exit();
#endif
}
