/**************************************************************************//**
* @brief Transmit single byte to the TFT
* @param c Character to transmit
* @return Transmitted character
*****************************************************************************/
int RETARGET_WriteChar(char c)
{
if ((BSP_RegisterRead(&BC_REGISTER->UIF_AEM) == BC_UIF_AEM_EFM))
{
if ((BSP_RegisterRead(&BC_REGISTER->ARB_CTRL) != BC_ARB_CTRL_EBI) || (initialized == false))
{
if (initialized)
{
bufferReset = false;
tftReset = true;
RETARGET_SerialInit();
}
else
{
bufferReset = true;
tftReset = true;
RETARGET_SerialInit();
}
fullUpdate = true;
}
}
/* Check for form feed - clear screen */
if (c == '\f')
{
bufferReset = true;
tftReset = false;
RETARGET_SerialInit();
fullUpdate = true;
return c;
}
/* Add CR or LF to CRLF if enabled */
if (LFtoCRLF && (c == '\n'))
{
RETARGET_TFTTX('\r');
}
RETARGET_TFTTX(c);
if (LFtoCRLF && (c == '\r'))
{
RETARGET_TFTTX('\n');
}
/* Update display */
RETARGET_TFTUpdate(fullUpdate);
fullUpdate = false;
return c;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
int result;
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize USART and map LF to CRLF */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
printf("\nEFM32LG_DK3650 HardFault handler example\n");
HardFault_TrapDivByZero();
HardFault_TrapUnaligned();
/* Enable one of these function calls */
// result = BadFunctionAccess();
// result = BadFunctionDiv();
result = BadFunctionUnaligned();
printf("ERROR: The fault was not trapped (result=%d)\n", result);
while(1);
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
I2C_Init_TypeDef i2cInit = I2C_INIT_DEFAULT;
TEMPSENS_Temp_TypeDef temp;
/* Define previous temp to invalid, just to ensure update first time */
TEMPSENS_Temp_TypeDef prevTemp = {1000, 0};
int prevShowFahrenheit = showFahrenheit;
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize TFT */
RETARGET_SerialInit();
printf("\nEFM32 I2C temperature sensor example\n\n");
/* Enable board control interrupts */
BSP_InterruptDisable(0xffff);
BSP_InterruptFlagsClear(0xffff);
BSP_InterruptEnable(BC_INTEN_JOYSTICK);
temperatureIRQInit();
/* Initialize I2C driver, using standard rate. Devices on DK itself */
/* supports fast mode, but in case some slower devices are added on */
/* prototype board, we use standard mode. */
I2CDRV_Init(&i2cInit);
/* Main loop - just read temperature and update LCD */
while (1)
{
if (TEMPSENS_TemperatureGet(I2C0,
TEMPSENS_DK_ADDR,
&temp) < 0)
{
printf("ERROR\n");
/* Enter EM2, no wakeup scheduled */
EMU_EnterEM2(true);
}
/* Update LCD display if any change. This is just an example of how */
/* to save some energy, since the temperature normally is quite static. */
/* The compare overhead is much smaller than actually updating the display. */
if ((prevTemp.i != temp.i) ||
(prevTemp.f != temp.f) ||
(prevShowFahrenheit != showFahrenheit))
{
temperatureUpdate(&temp);
}
prevTemp = temp;
prevShowFahrenheit = showFahrenheit;
/* Read every 2 seconds which is more than it takes worstcase to */
/* finish measurement inside sensor. */
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
}
int main(void)
{
/* Chip errata */
CHIP_Init();
/* Enable HFXO */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Enable deboug output over UART */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
/* Enable the segment LCD */
SegmentLCD_Init(false);
SegmentLCD_Write("USB");
printf("\nStarting USB Device...\n");
/* Set up GPIO interrupts */
gpioInit();
/* Start USB stack. Callback routines in callbacks.c will be called
* when connected to a host. */
USBD_Init(&initstruct);;
/*
* When using a debugger it is pratical to uncomment the following three
* lines to force host to re-enumerate the device.
*/
/* USBD_Disconnect(); */
/* USBTIMER_DelayMs( 1000 ); */
/* USBD_Connect(); */
while(1)
{
if ( USBD_SafeToEnterEM2() )
{
/* Enter EM2 when in suspend or disconnected */
EMU_EnterEM2(true);
}
else
{
/* When USB is active we can sleep in EM1. */
EMU_EnterEM1();
}
}
}
/*
*********************************************************************************************************
* main()
*
* Description : This is the standard entry point for C code. It is assumed that your code will call
* main() once you have performed all necessary initialization.
*
* Argument(s) : none.
*
* Return(s) : none.
*********************************************************************************************************
*/
int main(void)
{
#if (OS_TASK_NAME_EN > 0)
CPU_INT08U err;
#endif
/* Disable all interrupts until we are ready to accept
* them. */
CPU_IntDis();
/* Chip errata */
CHIP_Init();
/* setup SW0 for energyAware Profiler */
BSP_TraceSwoSetup();
/* Initialize serial port */
RETARGET_SerialInit();
/* Map LF to CRLF */
RETARGET_SerialCrLf(1);
/* Initialize "uC/OS-II, The Real-Time Kernel". */
OSInit();
/* Create the start task */
OSTaskCreateExt((void (*)(void *)) App_TaskStart,
(void *) 0,
(OS_STK *)&App_TaskStartStk[APP_CFG_TASK_START_STK_SIZE - 1],
(INT8U ) APP_CFG_TASK_START_PRIO,
(INT16U ) APP_CFG_TASK_START_PRIO,
(OS_STK *)&App_TaskStartStk[0],
(INT32U ) APP_CFG_TASK_START_STK_SIZE,
(void *) 0,
(INT16U )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR));
#if (OS_TASK_NAME_EN > 0)
OSTaskNameSet(APP_CFG_TASK_START_PRIO, (INT8U *)"Start", &err);
#endif
/* Start multitasking (i.e. give control to uC/OS-II). */
OSStart();
/* OSStart() never returns, serious error had occured if
* code execution reached this point */
while(1) ;
}
/**************************************************************************//**
* @brief main - the entrypoint after reset.
*****************************************************************************/
int main( void )
{
#if !defined(BUSPOWERED)
BSP_Init(BSP_INIT_DEFAULT); /* Initialize DK board register access */
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
#endif
CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO );
CMU_OscillatorEnable(cmuOsc_LFXO, true, false);
#if !defined(BUSPOWERED)
RETARGET_SerialInit(); /* Initialize DK UART port */
RETARGET_SerialCrLf( 1 ); /* Map LF to CRLF */
printf( "\nEFM32 Mass Storage Device example\n" );
#endif
if ( !MSDDMEDIA_Init() )
{
#if !defined(BUSPOWERED)
printf( "\nMedia error !\n" );
#endif
EFM_ASSERT( false );
for( ;; ){}
}
MSDD_Init(gpioPortE, 1);
for (;;)
{
if ( MSDD_Handler() )
{
/* There is no pending activity in the MSDD handler. */
/* Enter sleep mode to conserve energy. */
if ( USBD_SafeToEnterEM2() )
EMU_EnterEM2(true);
else
EMU_EnterEM1();
}
}
}
/**************************************************************************//**
* @brief Transmit single byte to USART/LEUART
* @param c Character to transmit
* @return Transmitted character
*****************************************************************************/
int RETARGET_WriteChar(char c)
{
if (initialized == false)
{
RETARGET_SerialInit();
}
/* Add CR or LF to CRLF if enabled */
if (LFtoCRLF && (c == '\n'))
{
RETARGET_TX(RETARGET_UART, '\r');
}
RETARGET_TX(RETARGET_UART, c);
if (LFtoCRLF && (c == '\r'))
{
RETARGET_TX(RETARGET_UART, '\n');
}
return c;
}
/**************************************************************************//**
* @brief Receive a byte from USART/LEUART and put into global buffer
* @return -1 on failure, or positive character integer on sucesss
*****************************************************************************/
int RETARGET_ReadChar(void)
{
int c = -1;
if (initialized == false)
{
RETARGET_SerialInit();
}
INT_Disable();
if (rxCount > 0)
{
c = rxBuffer[rxReadIndex];
rxReadIndex++;
if (rxReadIndex == RXBUFSIZE)
{
rxReadIndex = 0;
}
rxCount--;
}
INT_Enable();
return c;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
I2C_Init_TypeDef i2cInit = I2C_INIT_DEFAULT;
uint8_t data[3];
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize TFT */
RETARGET_SerialInit();
printf("\nEFM32 I2C EEPROM example\n\n");
/* Enable board control interrupts */
BSP_InterruptDisable(0xffff);
BSP_InterruptFlagsClear(0xffff);
BSP_InterruptEnable(BC_INTEN_JOYSTICK);
BSP_InterruptEnable(BC_INTEN_PB);
eepromtestIRQInit();
/* Initialize I2C driver, using standard rate. Devices on DK itself */
/* supports fast mode, but in case some slower devices are added on */
/* prototype board, we use standard mode. */
I2CDRV_Init(&i2cInit);
/* Main loop - just read data and update LCD */
while (1)
{
/* Should data be reset to factory default? */
if (eepromReset)
{
eepromReset = false;
/* Data changed by user? */
data[0] = 0xFF;
data[1] = 0xFF;
data[2] = 0xFF;
if (EEPROM_Write(I2C0, EEPROM_DVK_ADDR, 0, data, 3) < 0)
{
printf("RST ERR\n");
/* Enter EM2, no wakeup scheduled */
EMU_EnterEM2(true);
}
}
if (EEPROM_Read(I2C0, EEPROM_DVK_ADDR, 0, data, 3) < 0)
{
printf("RD ERR\n");
/* Enter EM2, no wakeup scheduled */
EMU_EnterEM2(true);
}
eepromData = data[0];
eepromtestUpdateLCD(data);
/* Just enter EM2 until joystick pressed */
EMU_EnterEM2(true);
/* Data changed by user? */
if (eepromData != data[0])
{
data[0] = eepromData;
data[1] = eepromData + 1;
data[2] = eepromData + 2;
if (EEPROM_Write(I2C0, EEPROM_DVK_ADDR, 0, data, 3) < 0)
{
printf("WR ERR\n");
/* Enter EM2, no wakeup scheduled */
EMU_EnterEM2(true);
}
}
}
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-III ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
uint16_t osVersion1, osVersion2, osVersion3;
OS_ERR err = OS_ERR_NONE;
(void)p_arg; /* Note(1) */
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-III ticker */
OS_CPU_SysTickInit(OS_CPU_SysTickClkFreq() / OS_CFG_TICK_RATE_HZ);
#if (OS_TASK_STAT_EN > 0U)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Enable RS232A peripheral */
BSP_PeripheralAccess(BSP_RS232A, true);
/* Initialize Serial */
RETARGET_SerialInit();
/* Map LF to CRLF */
RETARGET_SerialCrLf(1);
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-3");
osVersion3 = OSVersion( &err );
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-III v%d.%02d.%02d on Energy Micro EFM32 DVK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-III ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Energy Micro EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.energymicro.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial ");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(&AppTaskStartTCB, &err);
/* Error had occured if code execution reached this point as suspend calls the scheduler
* that performs a context switch */
while (1U) ;
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-II ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
(void)p_arg; /* Note(1) */
uint16_t osVersion1, osVersion2, osVersion3;
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-II ticker */
OS_CPU_SysTickInit(CMU_ClockFreqGet(cmuClock_HFPER)/OS_TICKS_PER_SEC);
#if (OS_TASK_STAT_EN > 0)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-2");
/* As USART connectors are not available on the STK by default,
* therefore printf() functions are turned off.
* Uncomment the macro definition in includes.h if serial
* is connected to your STK board (USART1 or LEUART0)! */
#ifdef USART_CONNECTED
/* Initialize serial port */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
osVersion3 = OSVersion();
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-II v%d.%02d.%02d on Silicon Labs EFM32WG STK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-II ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Silicon Labs EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.silabs.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
#endif /* end of #ifndef USART_CONNECTED */
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(APP_CFG_TASK_START_PRIO);
while (1)
{/* endless loop of Start task */
;
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
int c;
MPU_RegionInit_TypeDef flashInit = MPU_INIT_FLASH_DEFAULT;
MPU_RegionInit_TypeDef sramInit = MPU_INIT_SRAM_DEFAULT;
MPU_RegionInit_TypeDef peripheralInit = MPU_INIT_PERIPHERAL_DEFAULT;
/* Chip revision alignment and errata fixes */
CHIP_Init();
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DK_SPI);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Enable printf on RS232 port - this example only supports LEUART */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
printf("\nEFM32 MPU access violation example.\n"
"Hit lowercase 'x' to force access violations.\n");
MPU_Disable();
/* Flash memory */
MPU_ConfigureRegion( &flashInit );
/* SRAM */
MPU_ConfigureRegion( &sramInit );
/* SRAM, a 4k part with priviledged only access, this regions settings */
/* will override those of the previous region */
sramInit.regionNo = 2;
sramInit.baseAddress = RAM_MEM_BASE + 0x2000;
sramInit.size = mpuRegionSize4Kb;
sramInit.accessPermission = mpuRegionApPRw;
MPU_ConfigureRegion( &sramInit );
/* LEUART, priviledged only access */
peripheralInit.regionNo = 3;
peripheralInit.baseAddress = LEUART1_BASE;
peripheralInit.size = mpuRegionSize128b;
peripheralInit.accessPermission = mpuRegionApPRw;
MPU_ConfigureRegion( &peripheralInit );
MPU_Enable( MPU_CTRL_PRIVDEFENA ); /* Full access to default memory map */
/* in priviledged state */
while (1)
{
EMU_EnterEM2(true);
/* Retrieve new character */
c = getchar();
if (c > 0)
{
if ( c == 'x' )
{
/* Generate an access violation in LEUART1 peripheral */
__set_CONTROL( 1 ); /* Enter User (unpriviledged) state */
putchar( c );
/* MemManage_Handler() will set back to priviledged state */
/* Generate an access violation in internal SRAM */
__set_CONTROL( 1 ); /* Enter User (unpriviledged) state */
*(volatile uint32_t *)(RAM_MEM_BASE + 0x2000) = 1;
/* MemManage_Handler() will set back to priviledged state */
}
else
{
/* Echo character */
putchar(c);
}
}
/* Most terminals issue CR when pressing enter, add LF */
if (c == '\r')
{
putchar('\n');
}
}
}
/**************************************************************************//**
* @brief Initialize console I/O redirection.
*****************************************************************************/
static void ConsoleDebugInit(void)
{
RETARGET_SerialInit(); /* Initialize USART */
RETARGET_SerialCrLf(1); /* Map LF to CRLF */
}
/*
*********************************************************************************************************
* main()
*
* Description : This is the standard entry point for C code. It is assumed that your code will call
* main() once you have performed all necessary initialization.
*
* Argument(s) : none.
*
* Return(s) : none.
*********************************************************************************************************
*/
int main(void)
{
uint16_t osVersion1, osVersion2, osVersion3;
#if (OS_TASK_NAME_EN > 0)
CPU_INT08U err;
#endif
/* Disable all interrupts until we are ready to accept
* them. */
CPU_IntDis();
/* Chip errata */
CHIP_Init();
/* setup SW0 for energyAware Profiler */
setupSWO();
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize "uC/OS-II, The Real-Time Kernel". */
OSInit();
/* Initialize the uC/OS-II ticker */
OS_CPU_SysTickInit(CMU_ClockFreqGet(cmuClock_HFPER)/OS_TICKS_PER_SEC);
#if (OS_TASK_STAT_EN > 0)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-2");
/* As USART connectors are not available on the STK by default,
* therefore printf() functions are turned off.
* Uncomment the macro definition in includes.h if serial
* is connected to your STK board (USART1 or LEUART0)! */
#ifdef USART_CONNECTED
/* Initialize */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
osVersion3 = OSVersion();
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-II v%d.%02d.%02d on Silicon Labs EFM32TG STK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-II ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Silicon Labs EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.silabs.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial ");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
#endif /* end of #ifndef USART_CONNECTED */
/* Start multitasking (i.e. give control to uC/OS-II). */
OSStart();
/* OSStart() never returns, serious error had occured if
* code execution reached this point */
while(1) ;
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
uint8_t prod_rev;
uint32_t temp;
uint32_t temp_offset;
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize TFT */
RETARGET_SerialInit();
printf("\nEFM32 onchip temperature sensor example\n\n");
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_ADC0, true);
CMU_ClockEnable(cmuClock_GPIO, true);
/* Enable board control interrupts */
BSP_InterruptDisable(0xffff);
BSP_InterruptFlagsClear(0xffff);
BSP_InterruptEnable(BC_INTEN_JOYSTICK);
temperatureIRQInit();
/* This is a work around for Chip Rev.D Errata, Revision 0.6. */
/* Check for product revision 16 and 17 and set the offset */
/* for ADC0_TEMP_0_READ_1V25. */
prod_rev = (DEVINFO->PART & _DEVINFO_PART_PROD_REV_MASK) >> _DEVINFO_PART_PROD_REV_SHIFT;
if( (prod_rev == 16) || (prod_rev == 17) )
{
temp_offset = 112;
}
else
{
temp_offset = 0;
}
/* Setup ADC for sampling internal temperature sensor. */
setupSensor();
/* Main loop - just read temperature and update LCD */
while (1)
{
/* Start one ADC sample */
ADC_Start(ADC0, adcStartSingle);
/* Wait in EM1 for ADC to complete */
EMU_EnterEM1();
/* Read sensor value */
/* According to rev. D errata ADC0_TEMP_0_READ_1V25 should be decreased */
/* by the offset but it is the same if ADC reading is increased - */
/* reference manual 28.3.4.2. */
temp = ADC_DataSingleGet(ADC0) + temp_offset;
/* Convert ADC sample to Fahrenheit / Celsius and print string to display */
if (showFahrenheit)
{
printf("%1.1f F\n", convertToFahrenheit(temp));
}
else
{
printf("%1.1f C\n", convertToCelsius(temp));
}
/* Sleep for 2 seconds in EM 2 */
RTCDRV_Trigger(2000, NULL);
EMU_EnterEM2(true);
}
}
/**************************************************************************//**
* @brief Main function
*****************************************************************************/
int main(void)
{
int c;
int index;
/* Initialize DK board register access */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize USART and map LF to CRLF */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
#ifdef RETARGET_LEUART1
printf("\nEFM32WG_DK3850 LEUART1 example\n");
#else
printf("\nEFM32WG_DK3850 UART1 example\n");
#endif
for (index = 0; index < ECHOBUFSIZE; index++)
{
echoBuffer[index] = (char) 'a' + index;
}
/* Retrieve characters, print local echo and full line back */
index = 0;
while (1)
{
/* Retrieve new character */
c = getchar();
if (c > 0)
{
/* Output character - most terminals use CRLF */
if (c == '\r')
{
echoBuffer[index] = '\0';
/* Output entire line */
printf("\n%s\n", echoBuffer);
index = 0;
}
else
{
/* Filter non-printable characters */
if ((c < ' ') || (c > '~'))
continue;
/* Enter into buffer */
echoBuffer[index] = c;
index++;
if (index == ECHOBUFSIZE)
{
/* Flush buffer */
index = 0;
}
/* Local echo */
putchar(c);
}
}
else
{
#ifdef RETARGET_LEUART1
/* Enter EM2 when idle */
EMU_EnterEM2(true);
#else
/* Enter EM1 when idle */
EMU_EnterEM1();
#endif
}
}
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-III ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
uint16_t osVersion1, osVersion2, osVersion3;
OS_ERR err = OS_ERR_NONE;
(void)p_arg; /* Note(1) */
/* Use 48MHZ HFXO as core clock frequency */
CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFXO);
/* Initialize DK board register access */
/* This demo currently only works in EBI mode */
BSP_Init(BSP_INIT_DEFAULT);
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Initialize the uC/OS-III ticker */
OS_CPU_SysTickInit(CMU_ClockFreqGet(cmuClock_CORE) / OS_CFG_TICK_RATE_HZ);
#if (OS_TASK_STAT_EN > 0U)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
UART1_SerialInit();
UART1_SerialCrLf(1);
/* Initialize tft serial */
RETARGET_SerialInit();
osVersion3 = OSVersion( &err );
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
printf("\n*************************************");
printf("\n uC/OS-III v%d.%02d.%02d on EFM32 DK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-III ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n is running on ");
printf("\n Energy Micro EFM32 ");
printf("\n www.energymicro.com \n");
printf("\nDescription:");
printf("\n\nTask1: LED blink task");
printf("\n\nTask2: Receives characters from serial and posts message to Task3");
printf("\n\nTask3: Receives message from Task2 and writes it on screen");
printf("\n\n**************************************\n");
printf("\nStart typing...\n");
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(&AppTaskStartTCB, &err);
/* Error had occured if code execution reached this point as suspend calls the scheduler
* that performs a context switch */
while (1U) ;
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-II ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
(void)p_arg; /* Note(1) */
uint16_t osVersion1, osVersion2, osVersion3;
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-II ticker */
OS_CPU_SysTickInit(CMU_ClockFreqGet(cmuClock_HFPER)/OS_TICKS_PER_SEC);
#if (OS_TASK_STAT_EN > 0)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Enable RS232A peripheral */
BSP_PeripheralAccess(BSP_RS232_UART, true);
/* Initialize serial port */
RETARGET_SerialInit();
/* Map LF to CRLF */
RETARGET_SerialCrLf(1);
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-2");
osVersion3 = OSVersion();
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-II v%d.%02d.%02d on Silicon Labs EFM32G_DK3550 ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-II ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Silicon Labs EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.silabs.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial.");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(APP_CFG_TASK_START_PRIO);
while (1)
{/* endless loop of Start task */
;
}
}
/**************************************************************************//**
* The main entry point.
*****************************************************************************/
int main(void)
{
int msElapsed, i;
/* Set new vector table pointer */
SCB->VTOR = 0x20000000;
/* Enable peripheral clocks. */
CMU->HFPERCLKDIV = CMU_HFPERCLKDIV_HFPERCLKEN;
CMU->HFPERCLKEN0 = CMU_HFPERCLKEN0_GPIO | BOOTLOADER_USART_CLOCK |
AUTOBAUD_TIMER_CLOCK ;
/* Enable DMA interface */
CMU->HFCORECLKEN0 = CMU_HFCORECLKEN0_DMA;
#if defined( BL_DEBUG )
RETARGET_SerialInit(); /* Setup debug serialport etc. */
USB_PUTS( "EFM32 USB/USART0 bootloader\r\n" );
#endif
/* Calculate CRC16 for the bootloader itself and the Device Information page. */
/* This is used for production testing and can safely be omitted in */
/* your own code. */
bootloaderCRC = CRC_calc((void *) 0x0, (void *) BOOTLOADER_SIZE);
bootloaderCRC |= CRC_calc((void *) 0x0FE081B2, (void *) 0x0FE08200) << 16;
StartRTC();
#if !defined( SIMULATE_SWDCLK_PIN_HI )
while ( SWDCLK_PIN_IS_LO() )
{
USB_PUTS( "SWDCLK is low\r\n" );
if ( BOOT_checkFirmwareIsValid() )
{
USB_PUTS( "Booting application\r\n " );
BOOT_boot();
}
else
{
USB_PUTS( "No valid application, resetting EFM32... \r\n" );
/* Go to EM2 and wait for RTC wakeup. */
EMU_EnterEM2( false );
}
}
#endif
NVIC_DisableIRQ( RTC_IRQn );
/* Try to start HFXO. */
CMU_OscillatorEnable( cmuOsc_HFXO, true, false );
/* Wait approx. 1 second to see if HFXO starts. */
i = 1500000;
while ( i && !( CMU->STATUS & CMU_STATUS_HFXORDY ) )
{
i--;
}
USBTIMER_Init();
if ( i == 0 )
{
CMU_HFRCOBandSet( cmuHFRCOBand_28MHz );
}
else
{
CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO );
USBD_Init( &initstruct ); /* Start USB CDC functionality */
}
AUTOBAUD_start(); /* Start autobaud */
/* Wait 30 seconds for USART or USB connection */
msElapsed = 0;
while ( msElapsed < 30000 )
{
if ( AUTOBAUD_completed() )
break;
if ( CDC_Configured )
{
BOOTLDIO_setMode( CDC_Configured );
break;
}
USBTIMER_DelayMs( 100 );
msElapsed += 100;
}
AUTOBAUD_stop();
if ( msElapsed >= 30000 )
{
USB_PUTS( "USART0/USB timeout, resetting EFM32...\r\n " );
Disconnect( 0, 2000 );
SCB->AIRCR = 0x05FA0004; /* Reset EFM32. */
}
/* Print a message to show that we are in bootloader mode */
BOOTLDIO_printString("\r\n\r\n" BOOTLOADER_VERSION_STRING );
/* Print the chip ID. This is useful for production tracking */
BOOTLDIO_printHex(DEVINFO->UNIQUEH);
BOOTLDIO_printHex(DEVINFO->UNIQUEL);
BOOTLDIO_printString("\r\n");
/* Figure out correct flash geometry. */
FLASH_CalcPageSize();
/* Initialize flash for writing */
FLASH_init();
/* Start executing command line */
commandlineLoop();
}
/*
*********************************************************************************************************
* AppTaskStart()
*
* Description : The startup task. The uC/OS-III ticker should only be initialize once multitasking starts.
*
* Argument(s) : p_arg Argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Return(s) : none.
*
* Note(s) : (1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*
* (2) Interrupts are enabled once the task starts because the I-bit of the CCR register was
* set to 0 by 'OSTaskCreate()'.
*********************************************************************************************************
*/
static void App_TaskStart(void *p_arg)
{
uint16_t osVersion1, osVersion2, osVersion3;
OS_ERR err = OS_ERR_NONE;
(void)p_arg; /* Note(1) */
/* Initialize BSP functions */
BSPOS_Init();
/* Initialize the uC/OS-III ticker */
OS_CPU_SysTickInit(OS_CPU_SysTickClkFreq() / OS_CFG_TICK_RATE_HZ);
#if (OS_TASK_STAT_EN > 0U)
/* Determine CPU capacity */
OSStatInit();
#endif
/* Create application tasks */
App_TaskCreate();
/* Create application mailboxes */
App_MailboxCreate();
/* Initialize LCD */
SegmentLCD_Init(true);
/* Turn gecko symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
/* Turn EFM32 symbol ON */
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Write welcome message on LCD */
SegmentLCD_Write("uC/OS-3");
/* As USART connectors are not available on the STK by default,
* therefore printf() functions are turned off.
* Uncomment the macro definition in includes.h if serial
* is connected to your STK board (USART1 or LEUART0)! */
#ifdef USART_CONNECTED
/* Initialize serial port */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
osVersion3 = OSVersion( &err );
osVersion1 = osVersion3 / 10000;
osVersion3 -= osVersion1 * 10000;
osVersion2 = osVersion3 / 100;
osVersion3 -= osVersion2 * 100;
osVersion3 %= 100;
/* Write welcome message on serial */
printf("\n*****************************************************************************");
printf("\n uC/OS-III v%d.%02d.%02d on Energy Micro EFM32 STK ",
osVersion1, osVersion2, osVersion3 );
printf("\n Demo Application \n");
printf("\n uC/OS-III ");
printf("\n \"The real time kernel\" ");
printf("\n www.micrium.com ");
printf("\n\n is running on ");
printf("\n\n Energy Micro EFM32 ");
printf("\n \"The world's most energy friendly microcontrollers\" ");
printf("\n www.energymicro.com \n");
printf("\nDescription:");
printf("\nTask1: LED blink task");
printf("\nTask2: Receives characters from serial and posts message to Task3");
printf("\nTask3: Receives message from Task2 and writes it on LCD and serial.");
printf("\n*****************************************************************************\n");
printf("\nStart typing...\n");
#endif /* end of #ifndef USART_CONNECTED */
/* Suspend this task as it is only used once in one Reset cycle */
OSTaskSuspend(&AppTaskStartTCB, &err);
/* Error had occured if code execution reached this point as suspend calls the scheduler
* that performs a context switch */
while (1U) ;
}
/**************************************************************************//**
* @brief main - the entrypoint after reset.
*****************************************************************************/
int main(void)
{
uint32_t time;
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
/* Select 48MHz clock. */
CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO );
/* Setup EBI for NAND Flash. */
BSP_EbiInit();
/* Enable DWT */
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
/* Make sure CYCCNT is running */
DWT_CTRL |= 1;
/* Initialize USART and map LF to CRLF */
RETARGET_SerialInit();
RETARGET_SerialCrLf(1);
printf("\nEFM32GG_STK3700 NAND Flash example\n");
printHelp();
/* Initialize nand flash module, use DMA channel 5. */
NANDFLASH_Init( 5 );
while (1)
{
getCommand();
/* Get misc. NAND flash info */
if ( !strcmp( argv[0], "fi" ) )
{
printf( " NAND flash device information:\n" );
printf( "\n Manufacturer Code : 0x%02X", NANDFLASH_DeviceInfo()->manufacturerCode );
printf( "\n Device Code : 0x%02X", NANDFLASH_DeviceInfo()->deviceCode );
printf( "\n Device size : %ld (%ldMB)", NANDFLASH_DeviceInfo()->deviceSize,
NANDFLASH_DeviceInfo()->deviceSize/1024/1024 );
printf( "\n Page size : %ld", NANDFLASH_DeviceInfo()->pageSize );
printf( "\n Spare size : %ld", NANDFLASH_DeviceInfo()->spareSize );
printf( "\n Block size : %ld", NANDFLASH_DeviceInfo()->blockSize );
putchar( '\n' );
}
/* Read a page */
else if ( !strcmp( argv[0], "rp" ) )
{
int status;
uint32_t pageNum, addr;
pageNum = strtoul( argv[1], NULL, 0 );
addr = PAGENUM_2_ADDR( pageNum );
if ( !NANDFLASH_AddressValid( addr ) )
{
printf( " Read page content, page %ld is not a valid page\n", pageNum );
}
else
{
time = DWT_CYCCNT;
status = NANDFLASH_ReadPage( addr, buffer[0] );
time = DWT_CYCCNT - time;
if ( status == NANDFLASH_STATUS_OK )
{
printf( " Read page %ld content, %ld cpu-cycles used\n", pageNum, time );
}
else
{
printf( " Read page error %d, %ld cpu-cycles used\n", status, time );
}
dumpPage( addr, buffer[0] );
}
}
/* Blankcheck a page */
else if ( !strcmp( argv[0], "bp" ) )
{
uint32_t pageNum, addr;
pageNum = strtoul( argv[1], NULL, 0 );
addr = PAGENUM_2_ADDR( pageNum );
if ( !NANDFLASH_AddressValid( addr ) )
{
printf( " Blankcheck page, page %ld is not a valid page\n", pageNum );
}
else
{
printf( " Blankchecking page %ld\n", pageNum );
if ( blankCheckPage( addr, buffer[0] ) )
{
printf( " Page %ld is blank\n", pageNum );
}
}
}
/* Blankcheck entire device */
else if ( !strcmp( argv[0], "bd" ) )
{
uint32_t addr;
int i, pageSize, pageCount;
pageSize = NANDFLASH_DeviceInfo()->pageSize;
pageCount = NANDFLASH_DeviceInfo()->deviceSize / pageSize;
addr = NANDFLASH_DeviceInfo()->baseAddress;
printf( " Blankchecking entire device\n" );
for ( i=0; i<pageCount; i++, addr+=pageSize )
{
if ( !blankCheckPage( addr, buffer[0] ) )
{
break;
}
}
if ( i == pageCount )
{
printf( " Device is blank\n" );
}
}
/* Check bad-block info */
else if ( !strcmp( argv[0], "bb" ) )
{
uint32_t addr;
int i, blockSize, blockCount, badBlockCount = 0;
blockCount = NANDFLASH_DeviceInfo()->deviceSize / NANDFLASH_DeviceInfo()->blockSize;
blockSize = NANDFLASH_DeviceInfo()->blockSize;
addr = NANDFLASH_DeviceInfo()->baseAddress;
for ( i=0; i<blockCount; i++, addr+=blockSize )
{
NANDFLASH_ReadSpare( addr, buffer[0] );
/* Manufacturer puts bad-block info in byte 6 of the spare area */
/* of the first page in each block. */
if ( buffer[0][NAND_SPARE_BADBLOCK_POS] != 0xFF )
{
printf( " ---> Bad-block at address 0x%08lX (block %ld) <---\n",
addr, ADDR_2_BLOCKNUM(addr) );
badBlockCount++;
}
}
if ( badBlockCount == 0 )
{
printf( " Device has no bad-blocks\n" );
}
}
/* Write a page */
else if ( !strcmp( argv[0], "wp" ) )
{
int i, status;
uint32_t pageNum, addr;
pageNum = strtoul( argv[1], NULL, 0 );
addr = PAGENUM_2_ADDR( pageNum );
if ( !NANDFLASH_AddressValid( addr ) )
{
printf( " Write page, page %ld is not a valid page\n", pageNum );
}
else
{
printf( " Write page %ld, ", pageNum );
for ( i=0; i<BUF_SIZ; i++ )
{
buffer[0][i] = i;
}
time = DWT_CYCCNT;
status = NANDFLASH_WritePage( addr, buffer[0] );
time = DWT_CYCCNT - time;
printf( "ecc : 0x%08lX\n", NANDFLASH_DeviceInfo()->ecc );
if ( status == NANDFLASH_STATUS_OK )
{
printf( " Page written OK, %ld cpu-cycles used\n", time );
}
else if ( status == NANDFLASH_WRITE_ERROR )
{
printf( " Page write failure, bad-block\n" );
}
else
{
printf( " Page write error %d\n", status );
}
}
}
/* Erase a block */
else if ( !strcmp( argv[0], "eb" ) )
{
int status;
uint32_t blockNum, addr;
blockNum = strtoul( argv[1], NULL, 0 );
addr = BLOCKNUM_2_ADDR( blockNum );
if ( !NANDFLASH_AddressValid( addr ) )
{
printf( " Erase block, block %ld is not a valid block\n", blockNum );
}
else
{
printf( " Erase block %ld, ", blockNum );
status = NANDFLASH_EraseBlock( addr );
if ( status == NANDFLASH_STATUS_OK )
{
printf( " Block erased OK\n" );
}
else if ( status == NANDFLASH_WRITE_ERROR )
{
printf( " Block erase failure, bad-block\n" );
}
else
{
printf( " Block erase error %d\n", status );
}
}
}
/* Check ECC algorithm */
else if ( !strcmp( argv[0], "ecc" ) )
{
int i, status;
uint32_t addr0, addr1, ecc0, ecc1, pageNum;
for ( i=0; i<BUF_SIZ; i++ )
{
buffer[0][i] = i;
buffer[1][i] = i;
}
pageNum = strtoul( argv[1], NULL, 0 );
addr0 = PAGENUM_2_ADDR( pageNum );
addr1 = PAGENUM_2_ADDR( pageNum + 1 );
if ( !NANDFLASH_AddressValid( addr0 ) ||
!NANDFLASH_AddressValid( addr1 ) )
{
printf( " Check ECC algorithm, page %ld or %ld is not a valid page\n",
pageNum, pageNum+1 );
}
else
{
printf( " Checking ECC algorithm\n" );
status = NANDFLASH_WritePage( addr0, buffer[0] );
if ( status != NANDFLASH_STATUS_OK )
{
printf( " Write in page <n> failed\n" );
}
ecc0 = NANDFLASH_DeviceInfo()->ecc; /* Get ECC generated during write*/
/* Patch one bit in the second buffer. */
buffer[1][147] ^= 4;
status = NANDFLASH_WritePage( addr1, buffer[1] );
if ( status != NANDFLASH_STATUS_OK )
{
printf( " Write in page <n+1> failed\n" );
}
ecc1 = NANDFLASH_DeviceInfo()->ecc; /* Get ECC generated during write*/
/* Try to correct the second buffer using ECC from first buffer */
NANDFLASH_EccCorrect( ecc0, ecc1, buffer[1] );
if ( memcmp( buffer[0], buffer[1], BUF_SIZ ) == 0 )
{
printf( " ECC correction succeeded\n" );
}
else
{
printf( " ECC correction failed\n" );
}
/* Byte 147 (addr 0x93) of page n+1 is now 0x97. */
/* Single step next function call, stop when ECC is read, set the */
/* read ECC to ecc10 (0) and verify that 0x97 is corrected to 0x93! */
NANDFLASH_ReadPage( addr1, buffer[1] );
}
}
/* Copy a page */
else if ( !strcmp( argv[0], "cp" ) )
{
int status;
uint32_t dstPageNum, srcPageNum, dstAddr, srcAddr;
dstPageNum = strtoul( argv[2], NULL, 0 );
srcPageNum = strtoul( argv[1], NULL, 0 );
dstAddr = PAGENUM_2_ADDR( dstPageNum );
srcAddr = PAGENUM_2_ADDR( srcPageNum );
if ( !NANDFLASH_AddressValid( dstAddr ) ||
!NANDFLASH_AddressValid( srcAddr ) )
{
printf( " Copy page, page %ld or %ld is not a valid page\n",
srcPageNum, dstPageNum );
}
else
{
printf( " Copying page %ld to page %ld\n", srcPageNum, dstPageNum );
status = NANDFLASH_CopyPage( dstAddr, srcAddr );
if ( status == NANDFLASH_STATUS_OK )
{
printf( " Page copied OK\n" );
}
else if ( status == NANDFLASH_WRITE_ERROR )
{
printf( " Page copy failure, bad-block\n" );
}
else
{
printf( " Page copy error %d\n", status );
}
}
}
/* Mark block as bad */
else if ( !strcmp( argv[0], "mb" ) )
{
uint32_t blockNum, addr;
blockNum = strtoul( argv[1], NULL, 0 );
addr = BLOCKNUM_2_ADDR( blockNum );
if ( !NANDFLASH_AddressValid( addr ) )
{
printf( " Mark bad block, %ld is not a valid block\n", blockNum );
}
else
{
printf( " Marked block %ld as bad\n", blockNum );
NANDFLASH_MarkBadBlock( addr );
}
}
/* Display help */
else if ( !strcmp( argv[0], "h" ) )
{
printHelp();
}
else
{
printf( " Unknown command" );
}
}
}