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) { } }