VOID OEMProfileTimerDisable()
{
BOOL enabled;
UINT32 irq;
OALMSG(TRUE, (L"+OEMProfileTimerDisable()\r\n"));
// No disable without enable
if (!g_profiler.enabled) goto cleanUp;
// Following code should not be interrupted
enabled = INTERRUPTS_ENABLE(FALSE);
// Disable the profile timer interrupt
irq = IRQ_TIMER2;
OALIntrDisableIrqs(1, &irq);
// Deconfigure profiling ISR callback function.
g_pProfilerISR = NULL;
// Reset flag
g_profiler.enabled = FALSE;
// Enable interrupts
INTERRUPTS_ENABLE(enabled);
cleanUp:
OALMSG(TRUE, (L"-OEMProfileTimerDisable\r\n"));
}
//------------------------------------------------------------------------------
//
// Function: OEMProfileTimerEnable
//
// This function is called by kernel to start kernel profiling timer.
//
VOID OEMProfileTimerEnable(DWORD interval)
{
BOOL enabled;
UINT32 irq;
OALMSG(TRUE, (L"+OEMProfileTimerEnable(%d)\r\n", interval));
// We can't enable timer second time
if (g_profiler.enabled) return;
// How many hi-res ticks per profiler hit
g_profiler.countsPerHit = (g_oalTimer.countsPerMSec * interval)/1000;
// Following code should not be interrupted
enabled = INTERRUPTS_ENABLE(FALSE);
// Configure profiling ISR callback function.
g_pProfilerISR = OALProfileIntrHandler;
// Obtain pointers to OST and INTC registers.
//
g_XllpOSTHandle.pOSTRegs = OALPAtoVA(BULVERDE_BASE_REG_PA_OST, FALSE);
g_XllpOSTHandle.pINTCRegs = OALPAtoVA(BULVERDE_BASE_REG_PA_INTC, FALSE);
// XLLI initializes oier and rtsr to zeroes, so no further
// initialization needs to be done. Match timers and
// alarms are disabled.
//
// Current usage of Match registers:
// M0 - Scheduler
// M1 - Touch Panel
// M2 - Profiler
// Update the compare register for the next profile hit.
//
XllpOstConfigureMatchReg(
&g_XllpOSTHandle, MatchReg2, g_profiler.countsPerHit
);
// Enable interrupts
INTERRUPTS_ENABLE(enabled);
irq = IRQ_OSMR2;
OALIntrDoneIrqs(1, &irq);
// Set flag
g_profiler.enabled = TRUE;
OALMSG(TRUE, (L"-OEMProfileTimerEnable\r\n"));
}
/*---------------------------------------------------------------------------*/
void
cfs_coffee_arch_erase(uint16_t sector)
{
watchdog_periodic();
INTERRUPTS_DISABLE();
rom_util_page_erase(COFFEE_START + sector * COFFEE_SECTOR_SIZE,
COFFEE_SECTOR_SIZE);
INTERRUPTS_ENABLE();
}
/*---------------------------------------------------------------------------*/
void
cfs_coffee_arch_write(const void *buf, unsigned int size, cfs_offset_t offset)
{
const uint32_t *src = buf;
uint32_t flash_addr = COFFEE_START + offset;
unsigned int align;
uint32_t word, len;
uint32_t page_buf[COFFEE_PAGE_SIZE / FLASH_WORD_SIZE];
unsigned int i;
if(size && (align = flash_addr & (FLASH_WORD_SIZE - 1))) {
len = MIN(FLASH_WORD_SIZE - align, size);
word = ~((*src & ((1 << (len << 3)) - 1)) << (align << 3));
watchdog_periodic();
INTERRUPTS_DISABLE();
rom_util_program_flash(&word, flash_addr & ~(FLASH_WORD_SIZE - 1),
FLASH_WORD_SIZE);
INTERRUPTS_ENABLE();
*(const uint8_t **)&src += len;
size -= len;
flash_addr += len;
}
while(size >= FLASH_WORD_SIZE) {
len = MIN(size & ~(FLASH_WORD_SIZE - 1), COFFEE_PAGE_SIZE);
for(i = 0; i < len / FLASH_WORD_SIZE; i++) {
page_buf[i] = ~*src++;
}
watchdog_periodic();
INTERRUPTS_DISABLE();
rom_util_program_flash(page_buf, flash_addr, len);
INTERRUPTS_ENABLE();
size -= len;
flash_addr += len;
}
if(size) {
word = ~(*src & ((1 << (size << 3)) - 1));
watchdog_periodic();
INTERRUPTS_DISABLE();
rom_util_program_flash(&word, flash_addr, FLASH_WORD_SIZE);
INTERRUPTS_ENABLE();
}
}
//------------------------------------------------------------------------------
//
// Function: OEMProfileTimerEnable
//
// This function is called by kernel to start kernel profiling timer.
//
VOID OEMProfileTimerEnable(DWORD interval)
{
BOOL enabled;
UINT32 irq;
OALMSG(TRUE, (L"+OEMProfileTimerEnable(%d)\r\n", interval));
// We can't enable timer second time
if (g_profiler.enabled) return;
// Obtain a pointer to the PWM registers.
if (!g_pPWMRegs)
{
g_pPWMRegs = (S3C2450_PWM_REG *) OALPAtoVA(S3C2450_BASE_REG_PA_PWM, FALSE);
}
// How many hi-res ticks per profiler hit
g_profiler.countsPerHit = (g_oalTimer.countsPerMSec * interval)/1000;
// Following code should not be interrupted
enabled = INTERRUPTS_ENABLE(FALSE);
// Configure profiling ISR callback function.
g_pProfilerISR = OALProfileIntrHandler;
// Update the compare register for the next profile hit.
ConfigureNextProfilerCount(g_profiler.countsPerHit);
// Enable interrupts
INTERRUPTS_ENABLE(enabled);
irq = IRQ_TIMER2;
OALIntrDoneIrqs(1, &irq);
// Set flag
g_profiler.enabled = TRUE;
OALMSG(TRUE, (L"-OEMProfileTimerEnable\r\n"));
}
/**
* \brief Main routine for the cc2538dk platform
*/
int main(void) {
// Just for test purposes
uint16_t temperature = 0;
uint16_t humidity = 0;
float* temperature_f;
float* humidity_f;
unsigned char* checksum;
unsigned char status;
unsigned char temp_data = 0xff;
/* unsigned char err = 0; SHT11 disabled */
nvic_init();
sys_ctrl_init();
clock_init();
lpm_init();
rtimer_init();
gpio_init();
ioc_init();
i2c_init();
leds_init();
fade(LEDS_YELLOW);
process_init();
watchdog_init();
button_sensor_init();
/*
* Character I/O Initialisation.
* When the UART receives a character it will call serial_line_input_byte to
* notify the core. The same applies for the USB driver.
*
* If slip-arch is also linked in afterwards (e.g. if we are a border router)
* it will overwrite one of the two peripheral input callbacks. Characters
* received over the relevant peripheral will be handled by
* slip_input_byte instead
*/
#if UART_CONF_ENABLE
uart_init();
uart_set_input(serial_line_input_byte);
#endif
#if USB_SERIAL_CONF_ENABLE
usb_serial_init();
usb_serial_set_input(serial_line_input_byte);
#endif
serial_line_init();
INTERRUPTS_ENABLE();
fade(LEDS_GREEN);
PUTS(CONTIKI_VERSION_STRING);PUTS(BOARD_STRING);
PRINTF(" Net: ");PRINTF("%s\n", NETSTACK_NETWORK.name);PRINTF(" MAC: ");PRINTF("%s\n", NETSTACK_MAC.name);PRINTF(" RDC: ");PRINTF("%s\n", NETSTACK_RDC.name);
/* Initialise the H/W RNG engine. */
random_init(0);
udma_init();
process_start(&etimer_process, NULL);
ctimer_init();
set_rime_addr();
netstack_init();
cc2538_rf_set_addr(IEEE802154_PANID);
#if UIP_CONF_IPV6
memcpy(&uip_lladdr.addr, &rimeaddr_node_addr, sizeof(uip_lladdr.addr));
queuebuf_init();
process_start(&tcpip_process, NULL);
#endif /* UIP_CONF_IPV6 */
process_start(&sensors_process, NULL);
energest_init();
ENERGEST_ON(ENERGEST_TYPE_CPU);
autostart_start(autostart_processes);
watchdog_start();
fade(LEDS_ORANGE);
while (1) {
uint8_t r;
do {
/* Reset watchdog and handle polls and events */
watchdog_periodic();
r = process_run();
/*
err = s_measure(&temperature, checksum, TEMP);
if (err == 0)
{
PRINTF("Temperature (ADC value) = 0x%4x\n", temperature);
err = s_measure(&humidity, checksum, HUMI);
if (err == 0)
{
PRINTF("Humidity (ADC value) = 0x%4x\n", humidity);
float tc=sht11_TemperatureC(temperature);
float hc=sht11_Humidity(temperature,humidity);
printf("temp:%u.%u\nhumidity:%u.%u\n",(int)tc,((int)(tc*10))%10 , (int)hc,((int)(hc*10))%10);
}
else
PRINTF("SHT11 error - could not read humidity!\n");
}
else
PRINTF("SHT11 error - could not read temperature!\n");
*/
/*err = s_write_statusreg(&temp_data);
if (err == 0)
{
err = s_read_statusreg(&status, checksum);
if (err == 0)
PRINTF("STATUS REGISTER = 0x%2x", status);
else
PRINTF("SHT11 error - could not read status register!\n");
}*/
} while (r > 0);
/* We have serviced all pending events. Enter a Low-Power mode. */
lpm_enter();
}
}
PROCESS_THREAD(hello_world_process, ev, data)
{
//static struct etimer timer;
PROCESS_BEGIN();
//begintimer();
//etimer_set(&timer, CLOCK_CONF_SECOND * 1);
uint32_t ui32PrevCount = 0;
//
// 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);
//
// 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.
//
printf(" 16-Bit Timer Interrupt ->\n\r");
printf(" Timer = Timer0B\n\r");
printf(" Mode = Periodic\n\r");
printf(" Number of interrupts = %d \n\r", NUMBER_OF_INTS);
printf(" Rate = 1ms\n\r");
//
// Configure Timer0B as a 16-bit periodic timer.
//
TimerConfigure(GPTIMER0_BASE, GPTIMER_CFG_SPLIT_PAIR |
GPTIMER_CFG_A_PERIODIC | GPTIMER_CFG_B_PWM);
/* TimerConfigure(GPTIMER0_BASE, GPTIMER_CFG_SPLIT_PAIR |
GPTIMER_CFG_A_PWM | GPTIMER_CFG_B_PWM); */
//
// Set the Timer0B load value to 1ms.
//
TimerLoadSet(GPTIMER0_BASE, GPTIMER_B, sys_ctrl_get_sys_clock() / 100 );
// TimerLoadSet(GPTIMER0_BASE, GPTIMER_B, SYS_CTRL_32MHZ );
//
// The following call will result in a dynamic interrupt table being used.
// The table resides in RAM.
// Alternatively SysTickIntHandler can be statically registred in your
// application.
//
TimerIntRegister(GPTIMER0_BASE, GPTIMER_B, Timer0BIntHandler);
//
// Enable processor interrupts.
//
//IntMasterEnable();
INTERRUPTS_ENABLE();
//
// Configure the Timer0B interrupt for timer timeout.
//
TimerIntEnable(GPTIMER0_BASE, GPTIMER_TIMB_TIMEOUT);
//
// Enable the Timer0B interrupt on the processor (NVIC).
//
IntEnable(INT_TIMER0B);
//
// Initialize the interrupt counter.
//
g_ui32Counter = 0;
//
// Enable Timer0B.
//
TimerEnable(GPTIMER0_BASE, GPTIMER_B);
//
// Loop forever while the Timer0B runs.
//
while(1)
{
//
// If the interrupt count changed, print the new value
//
if(ui32PrevCount != g_ui32Counter)
{
//
// Print the periodic interrupt counter.
//
printf("Number of interrupts: %d\r", g_ui32Counter);
ui32PrevCount = g_ui32Counter;
}
}
/*
while(1) {
//PROCESS_YIELD();
//if(ev == PROCESS_EVENT_TIMER) {
printf(" Hello Hi \n\r" );
//etimer_set(&timer, CLOCK_SECOND);
//}
}
*/
PROCESS_END();
}
/**
* \brief Main routine for the cc2538dk platform
*/
int
main(void)
{
nvic_init();
ioc_init();
sys_ctrl_init();
clock_init();
lpm_init();
rtimer_init();
gpio_init();
leds_init();
fade(LEDS_YELLOW);
process_init();
watchdog_init();
button_sensor_init();
/*
* Character I/O Initialisation.
* When the UART receives a character it will call serial_line_input_byte to
* notify the core. The same applies for the USB driver.
*
* If slip-arch is also linked in afterwards (e.g. if we are a border router)
* it will overwrite one of the two peripheral input callbacks. Characters
* received over the relevant peripheral will be handled by
* slip_input_byte instead
*/
#if UART_CONF_ENABLE
uart_init(0);
uart_init(1);
uart_set_input(SERIAL_LINE_CONF_UART, serial_line_input_byte);
#endif
#if USB_SERIAL_CONF_ENABLE
usb_serial_init();
usb_serial_set_input(serial_line_input_byte);
#endif
serial_line_init();
INTERRUPTS_ENABLE();
fade(LEDS_GREEN);
PUTS(CONTIKI_VERSION_STRING);
PUTS(BOARD_STRING);
PRINTF(" Net: ");
PRINTF("%s\n", NETSTACK_NETWORK.name);
PRINTF(" MAC: ");
PRINTF("%s\n", NETSTACK_MAC.name);
PRINTF(" RDC: ");
PRINTF("%s\n", NETSTACK_RDC.name);
/* Initialise the H/W RNG engine. */
random_init(0);
udma_init();
process_start(&etimer_process, NULL);
ctimer_init();
set_rf_params();
#if CRYPTO_CONF_INIT
crypto_init();
crypto_disable();
#endif
netstack_init();
#if NETSTACK_CONF_WITH_IPV6
memcpy(&uip_lladdr.addr, &linkaddr_node_addr, sizeof(uip_lladdr.addr));
queuebuf_init();
process_start(&tcpip_process, NULL);
#endif /* NETSTACK_CONF_WITH_IPV6 */
adc_init();
process_start(&sensors_process, NULL);
energest_init();
ENERGEST_ON(ENERGEST_TYPE_CPU);
autostart_start(autostart_processes);
watchdog_start();
fade(LEDS_ORANGE);
while(1) {
uint8_t r;
do {
/* Reset watchdog and handle polls and events */
watchdog_periodic();
r = process_run();
} while(r > 0);
/* We have serviced all pending events. Enter a Low-Power mode. */
lpm_enter();
}
}
//------------------------------------------------------------------------------
//
// Function: CS8900AGetFrame
//
UINT16
CS8900AGetFrame(UINT8 *pData, UINT16 *pLength)
{
UINT16 isq, length, status, count, data;
UINT16 DeviceInterrupt;
BOOL GlobalInterrupt;
OALMSGS(OAL_ETHER && OAL_VERBOSE, (
L"+CS8900AGetFrame(0x%08x, %d)\r\n", pData, *pLength
));
//
// This routine could be interrupt driven, or polled.
// When polled, it keeps the emulator so busy that it
// starves other threads. The emulator already has the
// ability to recognize the polling in the bootloader
// by noting whether the interrupt for this device is
// disabled. In order to make the emulator recognize it
// here as well, we need to detect the polling by noting
// that *global* interrupts are disabled, then disable at
// the device level as well if so.
//
GlobalInterrupt = INTERRUPTS_ENABLE(FALSE); // Disable to obtain state
INTERRUPTS_ENABLE(GlobalInterrupt); // Immediately restore it.
// Mimic the global interrupt state at the device level too.
if (!GlobalInterrupt) // If polled
{
// Disable at the device level too so the emulator knows we're polling.
// Now it can yeild to other threads on the host side.
DeviceInterrupt = ReadPacketPage(BUS_CTL);
WritePacketPage(BUS_CTL, DeviceInterrupt & ~BUS_CTL_ENABLE_IRQ);
DeviceInterrupt &= BUS_CTL_ENABLE_IRQ;
}
length = 0;
isq = INPORT16(&g_pCS8900->ISQ);
if ((isq & ISQ_ID_MASK) == RX_EVENT_ID
&& (isq & RX_EVENT_RX_OK) != 0)
{
// Get RxStatus and length
status = INPORT16(&g_pCS8900->DATA0);
length = INPORT16(&g_pCS8900->DATA0);
if (length > *pLength)
{
// If packet doesn't fit in buffer, skip it
data = ReadPacketPage(RX_CFG);
WritePacketPage(RX_CFG, data | RX_CFG_SKIP_1);
length = 0;
} else {
// Read packet data
count = length;
while (count > 1)
{
data = INPORT16(&g_pCS8900->DATA0);
*(UINT16*)pData = data;
pData += sizeof *(UINT16*)pData;
count -= sizeof *(UINT16*)pData;
}
// Read last one byte
if (count > 0)
{
data = INPORT16(&g_pCS8900->DATA0);
*pData = (UINT8)data;
}
}
}
if (!GlobalInterrupt) // If polled
{
if (DeviceInterrupt) // If it was enabled at the device level,
{
// Re-enable at the device level.
CS8900AEnableInts();
}
}
// Return packet size
*pLength = length;
OALMSGS(OAL_ETHER && OAL_VERBOSE, (
L"-CS8900AGetFrame(length = %d)\r\n", length
));
return (length);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
BOOL SHxIoCtllTiming (
UINT32 code, VOID *lpInBuf, UINT32 nInBufSize, VOID *lpOutBuf,
UINT32 nOutBufSize, UINT32 *lpBytesReturned
)
{
BOOL fEnable;
int nMSec;
PILTIMING_MESSAGE pITM;
if(lpBytesReturned)
{
*lpBytesReturned = 0;
}
if ((nInBufSize != sizeof(ILTIMING_MESSAGE)) || (lpInBuf == NULL))
{
RETAILMSG (1, (TEXT("IOCTL_HAL_ILTIMING : BAD PARAMETERS!!!\r\n")));
NKSetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
pITM = (PILTIMING_MESSAGE) lpInBuf;
switch (pITM->wMsg) {
case ILTIMING_MSG_ENABLE :
if (!(nMSec = (int) pITM->dwFrequency))
{
RETAILMSG (1, (TEXT("ILTiming dwFreqency cannot be 0\r\n")));
return FALSE;
}
fEnable = INTERRUPTS_ENABLE (FALSE);
g_oalILT.interrupts = 0;
g_oalILT.isrTime1 = 0xFFFFFFFF;
SHxStartTimer2 (nMSec * 1000);
g_oalILT.active = TRUE;
INTERRUPTS_ENABLE (fEnable);
RETAILMSG (1, (TEXT("ILTiming Enable (@ every %d MSec)\r\n"), nMSec));
break;
case ILTIMING_MSG_DISABLE :
RETAILMSG (1, (TEXT("ILTiming Disable\r\n")));
fEnable = INTERRUPTS_ENABLE (FALSE);
SHxStopTimer2();
g_oalILT.active = FALSE;
INTERRUPTS_ENABLE (fEnable);
break;
case ILTIMING_MSG_GET_TIMES :
pITM->dwIsrTime1 = g_oalILT.isrTime1;
pITM->dwIsrTime2 = g_oalILT.isrTime2;
pITM->wNumInterrupts = g_oalILT.interrupts;
pITM->dwSPC = g_oalILT.savedPC;
pITM->dwFrequency = PerfCountFreq();
g_oalILT.interrupts = 0;
RETAILMSG (1, (TEXT("ILTiming GetTime @ 0x%08X:%08X\r\n"), pITM->dwIsrTime1, pITM->dwIsrTime2));
break;
case ILTIMING_MSG_GET_PFN :
pITM->pfnPerfCountSinceTick = (PVOID) SHxTimer2CountSinceTick;
RETAILMSG (1, (TEXT("ILTiming GetPFN\r\n")));
break;
default :
RETAILMSG (1, (TEXT("IOCTL_HAL_ILTIMING : BAD MESSAGE!!!\r\n")));
return (FALSE);
}
return (TRUE);
}
/**
* \brief Main routine for the cc2538dk platform
*/
int
main(void)
{
nvic_init();
sys_ctrl_init();
clock_init();
dint();
/*Init Watchdog*/
watchdog_init();//Need to check the watchdog on 123gxl
rtimer_init();
lpm_init();
gpio_init();
ioc_init();
leds_init();
fade(LEDS_YELLOW);
button_sensor_init();
/*
* Character I/O Initialisation.
* When the UART receives a character it will call serial_line_input_byte to
* notify the core. The same applies for the USB driver.
*
* If slip-arch is also linked in afterwards (e.g. if we are a border router)
* it will overwrite one of the two peripheral input callbacks. Characters
* received over the relevant peripheral will be handled by
* slip_input_byte instead
*/
#if UART_CONF_ENABLE
uart_init(0);
uart_init(1);
uart_set_input(SERIAL_LINE_CONF_UART, serial_line_input_byte);
#endif
#if USB_SERIAL_CONF_ENABLE
usb_serial_init();
usb_serial_set_input(serial_line_input_byte);
#endif
serial_line_init();
/*Enable EA*/
eint();
INTERRUPTS_ENABLE();
fade(LEDS_GREEN);
PRINTF("=================================\r\n");
PUTS(CONTIKI_VERSION_STRING);
PRINTF("======================\r\n");
PRINTF("\r\n");
PUTS(BOARD_STRING);
PRINTF("\r\n");
#ifdef NODEID
node_id = NODEID;
#ifdef BURN_NODEID
node_id_burn(node_id);
node_id_restore(); /* also configures node_mac[] */
#endif /* BURN_NODEID */
#else
node_id_restore(); /* also configures node_mac[] */
#endif /* NODE_ID */
/* for setting "hardcoded" IEEE 802.15.4 MAC addresses */
#ifdef MAC_1
{
uint8_t ieee[] = { MAC_1, MAC_2, MAC_3, MAC_4, MAC_5, MAC_6, MAC_7, MAC_8 };
memcpy(node_mac, ieee, sizeof(uip_lladdr.addr));
}
#endif
/*
* Initialize Contiki and our processes.
*/
process_init();
process_start(&sensors_process, NULL);
button_sensor_init();
process_start(&etimer_process, NULL);
ctimer_init();
set_rime_addr();
printf("finish addr seting\r\n");
/* Initialise the H/W RNG engine. */
random_init(0);
udma_init();
if(node_id > 0) {
printf("Node id %u.\r\n", node_id);
} else {
printf("Node id not set.\r\n");
}
#if WITH_UIP6
memcpy(&uip_lladdr.addr, node_mac, sizeof(uip_lladdr.addr));
/* Setup nullmac-like MAC for 802.15.4 */
queuebuf_init();
netstack_init();
PRINTF("CC2538 IEEE802154 PANID %d\r\n", IEEE802154_PANID);
cc2538_rf_set_addr(IEEE802154_PANID);
printf("%s/%s %lu %u\r\n",
NETSTACK_RDC.name,
NETSTACK_MAC.name,
CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0 ? 1:
NETSTACK_RDC.channel_check_interval()),
RF_CHANNEL);
process_start(&tcpip_process, NULL);
printf("IPv6 ");
{
uip_ds6_addr_t *lladdr;
int i;
lladdr = uip_ds6_get_link_local(-1);
for(i = 0; i < 7; ++i) {
printf("%02x%02x:", lladdr->ipaddr.u8[i * 2],
lladdr->ipaddr.u8[i * 2 + 1]);
}
printf("%02x%02x\r\n", lladdr->ipaddr.u8[14], lladdr->ipaddr.u8[15]);
}
if(1) {
uip_ipaddr_t ipaddr;
int i;
uip_ip6addr(&ipaddr, 0xfc00, 0, 0, 0, 0, 0, 0, 0);
uip_ds6_set_addr_iid(&ipaddr, &uip_lladdr);
uip_ds6_addr_add(&ipaddr, 0, ADDR_TENTATIVE);
printf("Tentative global IPv6 address ");
for(i = 0; i < 7; ++i) {
printf("%02x%02x:",
ipaddr.u8[i * 2], ipaddr.u8[i * 2 + 1]);
}
printf("%02x%02x\r\n",
ipaddr.u8[7 * 2], ipaddr.u8[7 * 2 + 1]);
}
#else /* WITH_UIP6 */
netstack_init();
PRINTF("CC2538 IEEE802154 PANID %d\r\n", IEEE802154_PANID);
cc2538_rf_set_addr(IEEE802154_PANID);
printf("%s %lu %u\r\n",
NETSTACK_RDC.name,
CLOCK_SECOND / (NETSTACK_RDC.channel_check_interval() == 0? 1:
NETSTACK_RDC.channel_check_interval()),
RF_CHANNEL);
#endif /* WITH_UIP6 */
#if !WITH_UIP6
uart1_set_input(serial_line_input_byte);
serial_line_init();
#endif
#ifdef NETSTACK_AES_H
#ifndef NETSTACK_AES_KEY
#error Please define NETSTACK_AES_KEY!
#endif /* NETSTACK_AES_KEY */
{
const uint8_t key[] = NETSTACK_AES_KEY;
netstack_aes_set_key(key);
}
/*printf("AES encryption is enabled: '%s'\n", NETSTACK_AES_KEY);*/
printf("AES encryption is enabled\r\n");
#else /* NETSTACK_AES_H */
printf("Warning: AES encryption is disabled\r\n");
#endif /* NETSTACK_AES_H */
#if TIMESYNCH_CONF_ENABLED
timesynch_init();
timesynch_set_authority_level(rimeaddr_node_addr.u8[0]);
#endif /* TIMESYNCH_CONF_ENABLED */
energest_init();
ENERGEST_ON(ENERGEST_TYPE_CPU);
simple_rpl_init();
/*Watch dog configuration*/
watchdog_periodic();
watchdog_start();
autostart_start(autostart_processes);
//duty_cycle_scroller_start(CLOCK_SECOND * 2);
#if IP64_CONF_UIP_FALLBACK_INTERFACE_SLIP && WITH_SLIP
/* Start the SLIP */
printf("Initiating SLIP: my IP is 172.16.0.2...\r\n");
slip_arch_init(0);
{
uip_ip4addr_t ipv4addr, netmask;
uip_ipaddr(&ipv4addr, 172, 16, 0, 2);
uip_ipaddr(&netmask, 255, 255, 255, 0);
ip64_set_ipv4_address(&ipv4addr, &netmask);
}
uart1_set_input(slip_input_byte);
#endif /* IP64_CONF_UIP_FALLBACK_INTERFACE_SLIP */
fade(LEDS_ORANGE);
/*
* This is the scheduler loop.
*/
while(1) {
uint8_t r;
do {
/* Reset watchdog and handle polls and events */
// printf("reset watchdog\r\n");
watchdog_periodic();
r = process_run();
} while(r > 0);
/* We have serviced all pending events. Enter a Low-Power mode. */
lpm_enter();
}
}
//------------------------------------------------------------------------------
//
// Function: OEMPowerOff
//
// Called when the system is to transition to it's lowest power mode (off)
//
VOID
OEMPowerOff(
)
{
DWORD i;
UINT32 sysIntr;
UINT intr[3];
BOOL bPowerOn;
BOOL bPrevIntrState;
UINT irq = 0;
UINT32 mask = 0;
// disable interrupts (note: this should not be needed)
bPrevIntrState = INTERRUPTS_ENABLE(FALSE);
// UNDONE: verify if this is still necessary
// Disable hardware watchdog
OALWatchdogEnable(FALSE);
// Make sure that KITL is powered off
bPowerOn = FALSE;
KITLIoctl(IOCTL_KITL_POWER_CALL, &bPowerOn, sizeof(bPowerOn), NULL, 0, NULL);
//Save Perf Timer
OALContextSavePerfTimer();
// Disable GPTimer2 (used for high perf/monte carlo profiling)
EnableDeviceClocks(BSPGetGPTPerfDevice(), FALSE);
// Give chance to do board specific stuff
BSPPowerOff();
//----------------------------------------------
// capture all enabled interrupts and disable interrupts
intr[0] = INREG32(&g_pIntr->pICLRegs->INTC_MIR0);
intr[1] = INREG32(&g_pIntr->pICLRegs->INTC_MIR1);
intr[2] = INREG32(&g_pIntr->pICLRegs->INTC_MIR2);
OUTREG32(&g_pIntr->pICLRegs->INTC_MIR_SET0, OMAP_MPUIC_MASKALL);
OUTREG32(&g_pIntr->pICLRegs->INTC_MIR_SET1, OMAP_MPUIC_MASKALL);
OUTREG32(&g_pIntr->pICLRegs->INTC_MIR_SET2, OMAP_MPUIC_MASKALL);
//----------------------------------------------
// Context Save/Restore
// Save state then mask all GPIO interrupts
for (i=0; i<g_pIntr->nbGpioBank; i++)
{
INTR_GPIO_CTXT* pCurrGpioCtxt = &g_pIntr->pGpioCtxt[i];
// Save current state
pCurrGpioCtxt->restoreCtxt.IRQENABLE1 = INREG32(&pCurrGpioCtxt->pRegs->IRQENABLE1);
pCurrGpioCtxt->restoreCtxt.WAKEUPENABLE = INREG32(&pCurrGpioCtxt->pRegs->WAKEUPENABLE);
// Disable all GPIO interrupts in the bank
OUTREG32(&pCurrGpioCtxt->pRegs->IRQENABLE1, 0);
OUTREG32(&pCurrGpioCtxt->pRegs->WAKEUPENABLE, 0);
OALIntrEnableIrqs(1,&pCurrGpioCtxt->bank_irq);
}
//----------------------------------------------
// Clear all enabled IO PAD wakeups for GPIOs
for (i = 0; i < g_pIntr->nbGpioBank; ++i)
{
INTR_GPIO_CTXT* pCurrGpioCtxt = &g_pIntr->pGpioCtxt[i];
irq = BSPGetGpioIrq(0) + (i * 32);
mask = pCurrGpioCtxt->restoreCtxt.WAKEUPENABLE;
while (mask != 0)
{
// If a GPIO was wakeup enabled, then clear the wakeup
if (mask & 0x1)
{
OEMEnableIOPadWakeup((irq - BSPGetGpioIrq(0)), FALSE);
}
irq++;
mask >>= 1;
}
}
//----------------------------------------------
// Enable wake sources interrupts
for (sysIntr = SYSINTR_DEVICES; sysIntr < SYSINTR_MAXIMUM; sysIntr++)
{
// Skip if sysIntr isn't allowed as wake source
if (!OALPowerWakeSource(sysIntr))
continue;
// Enable it as interrupt
OEMInterruptEnable(sysIntr, NULL, 0);
}
// enter full retention
PrcmSuspend();
//----------------------------------------------
// Find wakeup source
for (sysIntr = SYSINTR_DEVICES; sysIntr < SYSINTR_MAXIMUM; sysIntr++)
{
// Skip if sysIntr isn't allowed as wake source
if (!OALPowerWakeSource(sysIntr))
continue;
// When this sysIntr is pending we find wake source
if (OEMInterruptPending(sysIntr))
{
g_oalWakeSource = sysIntr;
break;
}
}
//----------------------------------------------
// Context Save/Restore
// Put GPIO interrupt state back to the way it was before suspend
for (i=0; i<g_pIntr->nbGpioBank; i++)
{
INTR_GPIO_CTXT* pCurrGpioCtxt = &g_pIntr->pGpioCtxt[i];
// Write registers with the previously saved values
OUTREG32(&pCurrGpioCtxt->pRegs->IRQENABLE1, pCurrGpioCtxt->restoreCtxt.IRQENABLE1);
OUTREG32(&pCurrGpioCtxt->pRegs->WAKEUPENABLE, pCurrGpioCtxt->restoreCtxt.WAKEUPENABLE);
}
//-------------------------------------------------------
// Enable all previously enabled IO PAD wakeups for GPIOs
for (i = 0; i < g_pIntr->nbGpioBank; ++i)
{
INTR_GPIO_CTXT* pCurrGpioCtxt = &g_pIntr->pGpioCtxt[i];
irq = BSPGetGpioIrq(0) + (i * 32);
mask = pCurrGpioCtxt->restoreCtxt.WAKEUPENABLE;
while (mask != 0)
{
// If a GPIO was wakeup enabled, then clear the wakeup
if (mask & 0x1)
{
OEMEnableIOPadWakeup((irq - BSPGetGpioIrq(0)), TRUE);
}
irq++;
mask >>= 1;
}
}
//----------------------------------------------
// Re-enable interrupts
OUTREG32(&g_pIntr->pICLRegs->INTC_MIR_CLEAR0, ~intr[0]);
OUTREG32(&g_pIntr->pICLRegs->INTC_MIR_CLEAR1, ~intr[1]);
OUTREG32(&g_pIntr->pICLRegs->INTC_MIR_CLEAR2, ~intr[2]);
//----------------------------------------------
// Do board specific stuff
BSPPowerOn();
//Sync to Hardware RTC after suspend\resume
OALIoCtlHalRtcTime( 0, NULL, 0, NULL, 0, NULL);
// Enable GPTimer (used for high perf/monte carlo profiling)
EnableDeviceClocks(BSPGetGPTPerfDevice(), TRUE);
//Restore Perf Timer
OALContextRestorePerfTimer();
// Reinitialize KITL
bPowerOn = TRUE;
KITLIoctl(IOCTL_KITL_POWER_CALL, &bPowerOn, sizeof(bPowerOn), NULL, 0, NULL);
// Enable hardware watchdog
OALWatchdogEnable(TRUE);
#ifndef SHIP_BUILD
if (g_PrcmDebugSuspendResume)
{
OALMSG(1, (L"Enabled wake sources:\r\n"));
for (sysIntr = SYSINTR_FIRMWARE; sysIntr < SYSINTR_MAXIMUM; sysIntr++)
{
if (OALPowerWakeSource(sysIntr))
OALMSG(1, (L" SYSINTR %d\r\n", sysIntr));
}
OALMSG(1, (L"\r\nWake due to SYSINTR %d\r\n", g_oalWakeSource));
OALWakeupLatency_DumpSnapshot();
PrcmDumpSavedRefCounts();
DumpPrcmRegsSnapshot();
}
#endif
// restore interrupts
INTERRUPTS_ENABLE(bPrevIntrState);
}
/**
* \brief Main routine for the OpenMote-CC2538 platforms
*/
int
main(void)
{
nvic_init();
ioc_init();
sys_ctrl_init();
clock_init();
lpm_init();
rtimer_init();
gpio_init();
leds_init();
fade(LEDS_RED);
process_init();
watchdog_init();
#if UART_CONF_ENABLE
uart_init(0);
uart_init(1);
uart_set_input(SERIAL_LINE_CONF_UART, serial_line_input_byte);
#endif
#if USB_SERIAL_CONF_ENABLE
usb_serial_init();
usb_serial_set_input(serial_line_input_byte);
#endif
i2c_init(I2C_SDA_PORT, I2C_SDA_PIN, I2C_SCL_PORT, I2C_SCL_PIN, I2C_SCL_NORMAL_BUS_SPEED);
serial_line_init();
INTERRUPTS_ENABLE();
fade(LEDS_BLUE);
PUTS(CONTIKI_VERSION_STRING);
PUTS(BOARD_STRING);
#if STARTUP_CONF_VERBOSE
soc_print_info();
#endif
random_init(0);
udma_init();
process_start(&etimer_process, NULL);
ctimer_init();
board_init();
#if CRYPTO_CONF_INIT
crypto_init();
crypto_disable();
#endif
netstack_init();
set_rf_params();
PRINTF("Net: ");
PRINTF("%s\n", NETSTACK_NETWORK.name);
PRINTF("MAC: ");
PRINTF("%s\n", NETSTACK_MAC.name);
PRINTF("RDC: ");
PRINTF("%s\n", NETSTACK_RDC.name);
#if NETSTACK_CONF_WITH_IPV6
memcpy(&uip_lladdr.addr, &linkaddr_node_addr, sizeof(uip_lladdr.addr));
queuebuf_init();
process_start(&tcpip_process, NULL);
#endif /* NETSTACK_CONF_WITH_IPV6 */
process_start(&sensors_process, NULL);
SENSORS_ACTIVATE(button_sensor);
energest_init();
ENERGEST_ON(ENERGEST_TYPE_CPU);
autostart_start(autostart_processes);
watchdog_start();
fade(LEDS_GREEN);
while(1) {
uint8_t r;
do {
watchdog_periodic();
r = process_run();
} while(r > 0);
lpm_enter();
}
}
