static void system_init(void)
{
/**
* Configure the 32 kHz pins, PD6 and PD7, for crystal operation
* By default they are configured as GPIOs
*/
GPIODirModeSet(GPIO_D_BASE, 0x40, GPIO_DIR_MODE_IN);
GPIODirModeSet(GPIO_D_BASE, 0x80, GPIO_DIR_MODE_IN);
IOCPadConfigSet(GPIO_D_BASE, 0x40, IOC_OVERRIDE_ANA);
IOCPadConfigSet(GPIO_D_BASE, 0x80, IOC_OVERRIDE_ANA);
/**
* Set the real-time clock to use the 32.768 kHz external crystal
* Set the system clock to use the 32 MHz external crystal
*/
SysCtrlClockSet(true, false, SYS_CTRL_SYSDIV_32MHZ);
/**
* Set the IO clock to operate at 16 MHz
* This way peripherals can run while the system clock is gated
*/
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_16MHZ);
/**
* Wait until the 32 MHz oscillator becomes stable
*/
while (!((HWREG(SYS_CTRL_CLOCK_STA)) & (SYS_CTRL_CLOCK_STA_XOSC_STB)));
}
static void clock_init(void)
{
/**
* Disable global interrupts
*/
bool bIntDisabled = IntMasterDisable();
/**
* Configure the 32 kHz pins, PD6 and PD7, for crystal operation
* By default they are configured as GPIOs
*/
GPIODirModeSet(GPIO_D_BASE, 0x40, GPIO_DIR_MODE_IN);
GPIODirModeSet(GPIO_D_BASE, 0x80, GPIO_DIR_MODE_IN);
IOCPadConfigSet(GPIO_D_BASE, 0x40, IOC_OVERRIDE_ANA);
IOCPadConfigSet(GPIO_D_BASE, 0x80, IOC_OVERRIDE_ANA);
/**
* Set the real-time clock to use the 32khz internal crystal
* Set the system clock to use the external 32 MHz crystal
* Set the system clock to 32 MHz
*/
SysCtrlClockSet(true, false, SYS_CTRL_SYSDIV_32MHZ);
/**
* Set the IO clock to operate at 16 MHz
* This way peripherals can run while the system clock is gated
*/
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_16MHZ);
/**
* Wait until the selected clock configuration is stable
*/
while (!((HWREG(SYS_CTRL_CLOCK_STA)) & (SYS_CTRL_CLOCK_STA_XOSC_STB)));
/**
* Define what peripherals run in each mode
*/
SysCtrlDeepSleepSetting();
SysCtrlSleepSetting();
SysCtrlRunSetting();
SysCtrlWakeupSetting();
/**
* Re-enable interrupt if initially enabled.
*/
if(!bIntDisabled)
{
IntMasterEnable();
}
}
/*************************************************************************************************
* @fn sbUartInit()
*
* @brief Initialize the UART.
*
* @param none
*
* @return none
*/
void sbUartInit(void)
{
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Enable UART peripheral module
//
SysCtrlPeripheralEnable(SYS_CTRL_PERIPH_UART0);
//
// Disable UART function
//
UARTDisable(UART0_BASE);
//
// Disable all UART module interrupts
//
UARTIntDisable(UART0_BASE, 0x1FFF);
//
// Set IO clock as UART clock source
//
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
//
// Map UART signals to the correct GPIO pins and configure them as
// hardware controlled.
//
IOCPinConfigPeriphOutput(GPIO_A_BASE, GPIO_PIN_1, IOC_MUX_OUT_SEL_UART0_TXD);
GPIOPinTypeUARTOutput(GPIO_A_BASE, GPIO_PIN_1);
IOCPinConfigPeriphInput(GPIO_A_BASE, GPIO_PIN_0, IOC_UARTRXD_UART0);
GPIOPinTypeUARTInput(GPIO_A_BASE, GPIO_PIN_0);
//
// Configure the UART for 115,200, 8-N-1 operation.
// This function uses SysCtrlClockGet() to get the system clock
// frequency. This could be also be a variable or hard coded value
// instead of a function call.
//
UARTConfigSetExpClk(UART0_BASE, SysCtrlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
UARTEnable(UART0_BASE);
}
//*****************************************************************************
//
// Configure the SysTick and SysTick interrupt with a period of 1 second.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for Systick operation.
//
InitConsole();
//
// Display a reset message
//
UARTprintf("Watchdog Reset!\n");
//
// Enable watchdog
//
WatchdogEnable(WATCHDOG_INTERVAL_32768);
while(1)
{
//
// Delay
//
WdDelay(100);
//
// Clear WD such that we do not get a reset!
//
WatchdogClear();
}
}
//*****************************************************************************
//
// Configure the device, erase an page and the program the page.
//
//*****************************************************************************
int
main(void)
{
int32_t i32Res;
uint32_t i;
char pcStrInRam[16] = "Hello ... world!";
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Erase a page
//
i32Res = FlashMainPageErase(PAGE_TO_ERASE_START_ADDR);
ASSERT(i32Res==0);
//
// Program a page in chunks
//
for(i=0; i<PAGE_SIZE; i+=sizeof(pcStrInRam))
{
i32Res = FlashMainPageProgram((uint32_t*) pcStrInRam,
PAGE_TO_ERASE_START_ADDR+i,
sizeof(pcStrInRam));
ASSERT(i32Res==0);
}
//
// Loop forever
//
while(1)
{
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(hello_world_process, ev, data)
{
static struct etimer timer;
static int count;
PROCESS_BEGIN();
/* i2c_init(I2C_SCL_PORT, I2C_SCL_PIN, I2C_SDA_PORT, I2C_SDA_PIN,
I2C_SCL_NORMAL_BUS_SPEED);*/
etimer_set(&timer, CLOCK_CONF_SECOND * 1);
count = 0;
relay_enable(PORT_D,LED_RELAY_PIN);
while(1) {
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_TIMER) {
if(count %2 == 0){
//relay_on(PORT_D,LED_RELAY_PIN);
int delayIndex;
unsigned int pwmDutyCycle = 0x0000;
//
// Initialize the interrupt counter.
//
int g_ui32Counter = 0;
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, 32000000);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(32000000);
//
// The Timer0 peripheral must be enabled for use.
//
SysCtrlPeripheralEnable(SYS_CTRL_PERIPH_GPT0);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for Timer operation.
//
//InitConsole();
//
// Display the example setup on the console.
//
UARTprintf("16-Bit Timer PWM ->");
UARTprintf("\n Timer = Timer0B");
UARTprintf("\n Mode = PWM with variable duty cycle");
//
// Configure GPTimer0A as a 16-bit PWM Timer.
//
TimerConfigure(GPTIMER0_BASE, GPTIMER_CFG_SPLIT_PAIR |
GPTIMER_CFG_A_PWM | GPTIMER_CFG_B_PWM);
//
// Set the GPTimer0B load value to 1sec by setting the timer load value
// to SYSCLOCK / 255. This is determined by:
// Prescaled clock = 16Mhz / 255
// Cycles to wait = 1sec * Prescaled clock
TimerLoadSet(GPTIMER0_BASE, GPTIMER_A, SysCtrlClockGet() / 4000);
TimerControlLevel(GPTIMER0_BASE, GPTIMER_A, false);
// Configure GPIOPortA.0 as the Timer0_InputCapturePin.1
IOCPinConfigPeriphOutput(GPIO_A_BASE, GPIO_PIN_0, IOC_MUX_OUT_SEL_GPT0_ICP1);
// Tell timer to use GPIOPortA.0
// Does Direction Selection and PAD Selection
GPIOPinTypeTimer(GPIO_A_BASE, GPIO_PIN_0);
//
// Enable processor interrupts.
//
IntMasterEnable();
//
// Enable GPTimer0B.
//
TimerEnable(GPTIMER0_BASE, GPTIMER_A);
UARTprintf("\n");
//
// Loop forever while the Timer0B runs.
//
while(1)
{
for (delayIndex = 0; delayIndex < 100000; delayIndex++);
pwmDutyCycle += 0x0F;
pwmDutyCycle &= 0xFFFF;
TimerMatchSet(GPTIMER0_BASE, GPTIMER_A, pwmDutyCycle);
UARTprintf("PWM DC Value: %04X -- %04X -- %04X\r",
pwmDutyCycle,
TimerValueGet(GPTIMER0_BASE, GPTIMER_A),
TimerMatchGet(GPTIMER0_BASE, GPTIMER_A) );
}
//SENSORS_ACTIVATE(cc2538_temp_sensor);
// printf( "%d is temp\n",cc2538_temp_sensor.value);
}
else {
//relay_off(PORT_D,LED_RELAY_PIN);
}
/* if(count %2 == 0)
{
relay_toggle(PORT_D,LED_RELAY_PIN);
relay_status(PORT_D,LED_RELAY_PIN);
}
*/
count ++;
etimer_reset(&timer);
}
}
PROCESS_END();
}
//*****************************************************************************
//
// Main function. Sets up the ADC to use the temperature sensor as input. Note
// that you must enable to RF Core in order to use the ADC.
// The function runs a while forever loop converting the readout from ADC
// to temperature values and print it on the console.
//
//*****************************************************************************
int
main(void)
{
uint16_t ui16Dummy;
double dOutputVoltage;
char pcTemp[20];
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Enable RF Core (needed to enable temp sensor)
//
SysCtrlPeripheralEnable(SYS_CTRL_PERIPH_RFC);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for Systick operation.
//
InitConsole();
//
// Display the setup on the console.
//
UARTprintf("ADC temp sens\n");
//
// Connect temp sensor to ADC
//
HWREG(CCTEST_TR0) |= CCTEST_TR0_ADCTM;
//
// Enable the temperature sensor
//
HWREG(RFCORE_XREG_ATEST) = 0x01;
//
// Configure ADC, Internal reference, 512 decimation rate (12bit)
//
SOCADCSingleConfigure(SOCADC_12_BIT, SOCADC_REF_INTERNAL);
//
// Loop forever.
//
while(1)
{
//
// Trigger single conversion on internal temp sensor
//
SOCADCSingleStart(SOCADC_TEMP_SENS);
//
// Wait until conversion is completed
//
while(!SOCADCEndOfCOnversionGet())
{
}
//
// Get data and shift down based on decimation rate
//
ui16Dummy = SOCADCDataGet() >> SOCADC_12_BIT_RSHIFT;
//
// Convert to temperature
//
dOutputVoltage = ui16Dummy * CONST;
dOutputVoltage = ((dOutputVoltage - OFFSET_0C) / TEMP_COEFF);
//
// Convert float to string
//
sprintf(pcTemp, "%.1f", dOutputVoltage);
//
// Print the result on UART
//
UARTprintf("ADC raw readout: %d\n", ui16Dummy);
UARTprintf("Temperature: %s", pcTemp);
UARTprintf(" C\n");
//
// Simple delay
//
for(int i=0;i<1000000;i++)
{
}
}
}
//*****************************************************************************
//
// Configure sleep timer, put system into deep sleep and watch sleep timer
// interrupt wakeup system again
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32Val;
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for SSI operation.
//
InitConsole();
//
// Display the setup on the console.
//
UARTprintf("Sleepmode timer\n");
//
// Disable UART0 when in deep sleep
//
SysCtrlPeripheralDeepSleepDisable(SYS_CTRL_PERIPH_UART0);
//
// Let system enter powermode 2 when going to deep sleep
//
SysCtrlPowerModeSet(SYS_CTRL_PM_2);
//
// Enable the Sleep Timer wakeup
//
GPIOIntWakeupEnable(GPIO_IWE_SM_TIMER);
//
// Enable sleep mode interrupt
//
IntEnable(INT_SMTIM);
//
// Set timer to 10000 above current value
//
ui32Val = SleepModeTimerCountGet();
SleepModeTimerCompareSet(ui32Val + 10000);
//
// Display the timer value on the console.
//
UARTprintf("Timer val = %d\n", ui32Val);
//
// Wait for UART to be flushed
//
while(UARTBusy(UART0_BASE))
{
}
//
// Go to sleep
//
SysCtrlDeepSleep();
//
// Display the timer value on the console.
//
ui32Val = SleepModeTimerCountGet();
UARTprintf("Timer val = %d (after wakeup)\n", ui32Val);
//
// Done - enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// Configure the UART and perform reads and writes using polled I/O.
//
//*****************************************************************************
int
main(void)
{
char cThisChar;
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Enable UART peripheral module
//
SysCtrlPeripheralEnable(SYS_CTRL_PERIPH_UART0);
//
// Disable UART function
//
UARTDisable(UART0_BASE);
//
// Disable all UART module interrupts
//
UARTIntDisable(UART0_BASE, 0x1FFF);
//
// Set IO clock as UART clock source
//
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
//
// Map UART signals to the correct GPIO pins and configure them as
// hardware controlled.
//
IOCPinConfigPeriphOutput(EXAMPLE_GPIO_BASE, EXAMPLE_PIN_UART_TXD, IOC_MUX_OUT_SEL_UART0_TXD);
GPIOPinTypeUARTOutput(EXAMPLE_GPIO_BASE, EXAMPLE_PIN_UART_TXD);
IOCPinConfigPeriphInput(EXAMPLE_GPIO_BASE, EXAMPLE_PIN_UART_RXD, IOC_UARTRXD_UART0);
GPIOPinTypeUARTInput(EXAMPLE_GPIO_BASE, EXAMPLE_PIN_UART_RXD);
//
// Configure the UART for 115,200, 8-N-1 operation.
// This function uses SysCtrlClockGet() to get the system clock
// frequency. This could be also be a variable or hard coded value
// instead of a function call.
//
UARTConfigSetExpClk(UART0_BASE, SysCtrlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
UARTEnable(UART0_BASE);
//
// Put a character to show start of example. This will display on the
// terminal.
//
UARTCharPut(UART0_BASE, '!');
//
// Enter a loop to read characters from the UART, and write them back
// (echo). When a line end is received, the loop terminates.
//
do
{
//
// Read a character using the blocking read function. This function
// will not return until a character is available.
//
cThisChar = UARTCharGet(UART0_BASE);
//
// Write the same character using the blocking write function. This
// function will not return until there was space in the FIFO and
// the character is written.
//
UARTCharPut(UART0_BASE, cThisChar);
//
// Stay in the loop until either a CR or LF is received.
//
} while((cThisChar != '\n') && (cThisChar != '\r'));
//
// Put a character to show the end of the example. This will display on
// the terminal.
//
UARTCharPut(UART0_BASE, '@');
//
// Enter an infinite loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// Main function, setup DMA and perform flash write. Verify the transaction.
//
//*****************************************************************************
int
main(void)
{
uint16_t i;
int32_t i32Res;
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for Systick operation.
//
InitConsole();
//
// Display the setup on the console.
//
UARTprintf("Example - Write to Flash using DMA.\n");
//
// Erase Flash page that will hold our transferred data
//
i32Res = FlashMainPageErase(PAGE_TO_ERASE_START_ADDR);
ASSERT(i32Res==0);
//
// Fill Source buffer (to be copied to flash) with some data
//
for(i=0; i<256; i++)
{
ucSourceBuffer[i] = '0' + (i % 10);
}
//
// Enable the uDMA controller.
//
uDMAEnable();
//
// Disable the uDMA channel to be used, before modifications are done.
//
uDMAChannelDisable(UDMA_CH2_FLASH);
//
// Set the base for the channel control table.
//
uDMAControlBaseSet(&ucDMAControlTable[0]);
//
// Assign the DMA channel
//
uDMAChannelAssign(UDMA_CH2_FLASH);
//
// Set attributes for the channel.
//
uDMAChannelAttributeDisable(UDMA_CH2_FLASH, UDMA_ATTR_HIGH_PRIORITY);
//
// Now set up the characteristics of the transfer.
// 32-bit data size, with source increments in words (32 bits),
// no destination increment.
// A bus arbitration size of 1 must be used.
//
uDMAChannelControlSet(UDMA_CH2_FLASH, UDMA_SIZE_32 | UDMA_SRC_INC_32 |
UDMA_DST_INC_NONE | UDMA_ARB_1);
//
// Set transfer parameters.
// Source address is the location of the data to write
// and destination address is the FLASH_CTRL_FWDATA register.
//
uDMAChannelTransferSet(UDMA_CH2_FLASH, UDMA_MODE_BASIC, ucSourceBuffer,
(void *) FLASH_CTRL_FWDATA, sizeof(ucSourceBuffer));
//
// Asure that the flash controller is not busy.
//
while(HWREG(FLASH_CTRL_FCTL) & FLASH_CTRL_FCTL_BUSY)
{
}
//
// Initialize Flash control register without changing the cache mode.
//
HWREG(FLASH_CTRL_FCTL) &= FLASH_CTRL_FCTL_CM_M;
//
// Setup Flash Address register to address of first data word (32-bit)
//
HWREG(FLASH_CTRL_FADDR) = PAGE_TO_ERASE_START_ADDR;
//
// Finally, the DMA channel must be enabled.
//
uDMAChannelEnable(UDMA_CH2_FLASH);
//
// Set FCTL.WRITE, to trigger flash write
//
HWREG(FLASH_CTRL_FCTL) |= FLASH_CTRL_FCTL_WRITE;
//
// Wait until all words has been programmed.
//
while( HWREG(FLASH_CTRL_FCTL) & FLASH_CTRL_FCTL_FULL )
{
}
//
// Check if flash write was successfull
//
if (HWREG(FLASH_CTRL_FCTL) & FLASH_CTRL_FCTL_ABORT)
{
UARTprintf("Write not successful!\n");
}
else
{
UARTprintf("Write success!\n");
}
//
// Set control register back to reset value without changing the cache mode.
//
HWREG(FLASH_CTRL_FCTL) &= FLASH_CTRL_FCTL_CM_M;
//
// Compare source buffer and destination flash page
//
if(memcmp(ucSourceBuffer, (void*) PAGE_TO_ERASE_START_ADDR, 256)==0)
{
UARTprintf("Buffer compares to flash page!\n");
}
else
{
UARTprintf("Buffer does not compare to flash page!\n");
}
//
// We are done, loop forever
//
while(1)
{
}
}
//*****************************************************************************
//
// Main function of example.
//
//*****************************************************************************
void main(void)
{
uint8_t status;
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Enable AES peripheral
//
SysCtrlPeripheralReset(SYS_CTRL_PERIPH_AES);
SysCtrlPeripheralEnable(SYS_CTRL_PERIPH_AES);
//
// Register AES interrupt
//
IntRegister(INT_AES, CCMIntHandler);
//
// Enable global interrupts
//
IntAltMapEnable();
IntMasterEnable();
for(uint8_t i = 0; i < sizeof(sCCMNodecryptExample)/
sizeof(sCCMNodecryptExample[0] ); i++)
{
//
// Run and Verify CCM Inverse Authentication only
//
status = CCMDecryptExamples(sCCMNodecryptExample[i].ui8CCMDecrypt,
sCCMNodecryptExample[i].ui8CCMKey,
sCCMNodecryptExample[i].ui8CCMMval,
sCCMNodecryptExample[i].ui8CCMN,
sCCMNodecryptExample[i].ui8CCMC,
sCCMNodecryptExample[i].ui16CCMLenC,
sCCMNodecryptExample[i].ui8CCMA,
sCCMNodecryptExample[i].ui16CCMLenA,
sCCMNodecryptExample[i].ui8CCMKeyLocation,
sCCMNodecryptExample[i].ui8CCMCstate,
sCCMNodecryptExample[i].ui8CCMLVal,
sCCMNodecryptExample[i].ui8CCMIntEnable,
sCCMNodecryptExample[i].
ui8CCMExpectedOutput);
if(status != AES_SUCCESS)
{
while(1)
{
//
// AES CCM failed
//
}
}
}
for(uint8_t i = 0; i < sizeof(sCCMNoencryptExample)/
sizeof(sCCMNoencryptExample[0] ); i++)
{
//
// Run and Verify CCM Authentication only
//
status = CCMEncryptExample(sCCMNoencryptExample[i].ui8CCMEncrypt,
sCCMNoencryptExample[i].ui8CCMkey,
sCCMNoencryptExample[i].ui8CCMMval,
sCCMNoencryptExample[i].ui8CCMN,
sCCMNoencryptExample[i].ui8CCMM,
sCCMNoencryptExample[i].ui16CCMLenM,
sCCMNoencryptExample[i].ui8CCMA,
sCCMNoencryptExample[i].ui16CCMLenA,
sCCMNoencryptExample[i].ui8CCMKeyLocation,
sCCMNoencryptExample[i].ui8CCMCstate,
sCCMNoencryptExample[i].ui8CCMCCMLVal,
sCCMNoencryptExample[i].ui8CCMIntEnable,
sCCMNoencryptExample[i].
ui8CCMExpectedOutput);
if(status != AES_SUCCESS)
{
while(1)
{
//
// AES CCM failed
//
}
}
}
for(uint8_t i = 0; i < sizeof(sCCMEncryptExample)/
sizeof(sCCMEncryptExample[0] ); i++)
{
//
// Run and Verify CCM Authentication + Encryption
//
status = CCMEncryptExample(sCCMEncryptExample[i].ui8CCMEncrypt,
sCCMEncryptExample[i].ui8CCMkey,
sCCMEncryptExample[i].ui8CCMMval,
sCCMEncryptExample[i].ui8CCMN,
sCCMEncryptExample[i].ui8CCMM,
sCCMEncryptExample[i].ui16CCMLenM,
sCCMEncryptExample[i].ui8CCMA,
sCCMEncryptExample[i].ui16CCMLenA,
sCCMEncryptExample[i].ui8CCMKeyLocation,
sCCMEncryptExample[i].ui8CCMCstate,
sCCMEncryptExample[i].ui8CCMCCMLVal,
sCCMEncryptExample[i].ui8CCMIntEnable,
sCCMEncryptExample[i].
ui8CCMExpectedOutput);
if(status != AES_SUCCESS)
{
while(1)
{
//
// AES CCM failed
//
}
}
}
for(uint8_t i = 0; i < sizeof(sCCMDecryptExample)/
sizeof(sCCMDecryptExample[0] ); i++)
{
//
// Run and Verify CCM Inverse Authentication + Decryption
//
status = CCMDecryptExamples(sCCMDecryptExample[i].ui8CCMDecrypt,
sCCMDecryptExample[i].ui8CCMKey,
sCCMDecryptExample[i].ui8CCMMval,
sCCMDecryptExample[i].ui8CCMN,
sCCMDecryptExample[i].ui8CCMC,
sCCMDecryptExample[i].ui16CCMLenC,
sCCMDecryptExample[i].ui8CCMA,
sCCMDecryptExample[i].ui16CCMLenA,
sCCMDecryptExample[i].ui8CCMKeyLocation,
sCCMDecryptExample[i].ui8CCMCstate,
sCCMDecryptExample[i].ui8CCMLVal,
sCCMDecryptExample[i].ui8CCMIntEnable,
sCCMDecryptExample[i].
ui8CCMExpectedOutput);
if(status != AES_SUCCESS)
{
while(1)
{
//
// AES CCM failed
//
}
}
}
// CCM was successful
while(1)
{
}
}
//*****************************************************************************
//
// Configure the SysTick and SysTick interrupt with a period of 1 second.
//
//*****************************************************************************
int
main(void)
{
uint16_t i;
//
// Set the clocking to run directly from the external crystal/oscillator.
// (no ext 32k osc, no internal osc)
//
SysCtrlClockSet(false, false, SYS_CTRL_SYSDIV_32MHZ);
//
// Set IO clock to the same as system clock
//
SysCtrlIOClockSet(SYS_CTRL_SYSDIV_32MHZ);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for Systick operation.
//
InitConsole();
//
// Display the setup on the console.
//
UARTprintf("DMA SW example mem to mem!\n");
//
// Fill Source buffer with some data
//
for(i=0; i<256; i++)
{
ucSourceBuffer[i] = '0' + (i % 10);
}
//
// Enable the uDMA controller.
//
uDMAEnable();
//
// Set the base for the channel control table.
//
uDMAControlBaseSet(&ucDMAControlTable[0]);
//
// No attributes must be set for a software-based transfer.
// The attributes are cleared by default, but are explicitly cleared
// here, in case they were set elsewhere.
//
uDMAChannelAttributeDisable(UDMA_CH30_SW, UDMA_ATTR_ALL);
//
// Now set up the characteristics of the transfer for
// 8-bit data size, with source and destination increments
// in bytes, and a byte-wise buffer copy. A bus arbitration
// size of 8 is used.
//
uDMAChannelControlSet(UDMA_CH30_SW | UDMA_PRI_SELECT,
UDMA_SIZE_8 | UDMA_SRC_INC_8 |
UDMA_DST_INC_8 | UDMA_ARB_8);
//
// The transfer buffers and transfer size are now configured.
// The transfer uses AUTO mode, which means that the
// transfer automatically runs to completion after the first
// request.
//
uDMAChannelTransferSet(UDMA_CH30_SW | UDMA_PRI_SELECT,
UDMA_MODE_AUTO, ucSourceBuffer, ucDestBuffer,
sizeof(ucDestBuffer));
//
// Enable Interrupt for DMA
//
IntEnable(INT_UDMA);
//
// Finally, the channel must be enabled. Because this is a
// software-initiated transfer, a request must also be made.
// The request starts the transfer.
//
uDMAChannelEnable(UDMA_CH30_SW);
uDMAChannelRequest(UDMA_CH30_SW);
//
// Put cpu to sleep and wait for interrupt (when DMA transfer is done)
//
SysCtrlSleep();
//
// Loop forever while the SysTick runs.
//
while(1)
{
}
}
