int
iBSP430consoleInitialize (void)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rv;
hBSP430halSERIAL hal;
if (console_hal_) {
return 0;
}
hal = hBSP430serialLookup(BSP430_CONSOLE_SERIAL_PERIPH_HANDLE);
if (NULL == hal) {
return -1;
}
rv = -1;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
#if BSP430_CONSOLE_RX_BUFFER_SIZE - 0
/* Associate the callback before opening the device, so the
* interrupts are enabled properly. */
rx_buffer_.head = rx_buffer_.tail = 0;
BSP430_HAL_ISR_CALLBACK_LINK_NI(sBSP430halISRVoidChainNode, hal->rx_cbchain_ni, rx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_RX_BUFFER_SIZE */
#if BSP430_CONSOLE_TX_BUFFER_SIZE - 0
uartTransmit_ni = console_tx_queue_ni;
tx_buffer_.wake_available = 0;
tx_buffer_.head = tx_buffer_.tail = 0;
BSP430_HAL_ISR_CALLBACK_LINK_NI(sBSP430halISRVoidChainNode, hal->tx_cbchain_ni, tx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_TX_BUFFER_SIZE */
/* Attempt to configure and install the console */
console_hal_ = hBSP430serialOpenUART(hal, 0, 0, BSP430_CONSOLE_BAUD_RATE);
if (! console_hal_) {
/* Open failed, revert the callback association. */
#if BSP430_CONSOLE_RX_BUFFER_SIZE - 0
BSP430_HAL_ISR_CALLBACK_UNLINK_NI(sBSP430halISRVoidChainNode, hal->rx_cbchain_ni, rx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_RX_BUFFER_SIZE */
break;
}
#if BSP430_PLATFORM_SPIN_FOR_JUMPER - 0
vBSP430platformSpinForJumper_ni();
#endif /* BSP430_PLATFORM_SPIN_FOR_JUMPER */
/* All is good */
rv = 0;
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
int
iBSP430consoleTransmitUseInterrupts_ni (int enablep)
{
#if BSP430_CONSOLE_TX_BUFFER_SIZE - 0
if (enablep) {
if (uartTransmit_ni != console_tx_queue_ni) {
uartTransmit_ni = console_tx_queue_ni;
vBSP430serialFlush_ni(console_hal_);
iBSP430serialSetHold_ni(console_hal_, 1);
BSP430_HAL_ISR_CALLBACK_LINK_NI(sBSP430halISRVoidChainNode, console_hal_->tx_cbchain_ni, tx_buffer_.cb_node, next_ni);
iBSP430serialSetHold_ni(console_hal_, 0);
if (tx_buffer_.head != tx_buffer_.tail) {
vBSP430serialWakeupTransmit_ni(console_hal_);
}
}
} else {
if (uartTransmit_ni != iBSP430uartTxByte_ni) {
uartTransmit_ni = iBSP430uartTxByte_ni;
vBSP430serialFlush_ni(console_hal_);
iBSP430serialSetHold_ni(console_hal_, 1);
BSP430_HAL_ISR_CALLBACK_UNLINK_NI(sBSP430halISRVoidChainNode, console_hal_->tx_cbchain_ni, tx_buffer_.cb_node, next_ni);
iBSP430serialSetHold_ni(console_hal_, 0);
}
}
return 0;
#else /* BSP430_CONSOLE_TX_BUFFER_SIZE */
return enablep ? -1 : 0;
#endif /* BSP430_CONSOLE_TX_BUFFER_SIZE */
}
void main ()
{
hBSP430halSERIAL console = NULL;
hBSP430halSERIAL uart = NULL;
unsigned long prep_utt = 0;
unsigned long emit_utt = 0;
unsigned long done_utt = 0;
vBSP430platformInitialize_ni();
iBSP430consoleInitialize();
console = hBSP430console();
cprintf("\ntxcb " __DATE__ " " __TIME__ "\n");
cprintf("\nConsole %p is on %s: %s\n", console,
xBSP430serialName(BSP430_CONSOLE_SERIAL_PERIPH_HANDLE),
xBSP430platformPeripheralHelp(BSP430_CONSOLE_SERIAL_PERIPH_HANDLE, 0));
uart = hBSP430serialLookup(UART_PERIPH_HANDLE);
if (NULL == uart) {
cprintf("Failed to resolve secondary\n");
return;
}
cprintf("\nSecondary %p is on %s: %s\n", uart,
xBSP430serialName(UART_PERIPH_HANDLE),
xBSP430platformPeripheralHelp(UART_PERIPH_HANDLE, 0));
tx_buffer_.head = tx_buffer_.tail = 0;
BSP430_HAL_ISR_CALLBACK_LINK_NI(sBSP430halISRVoidChainNode, uart->tx_cbchain_ni, tx_buffer_.cb_node, next_ni);
uart = hBSP430serialOpenUART(uart, 0, 0, 9600);
if (NULL == uart) {
cprintf("Secondary open failed\n");
}
/* Need to enable interrupts so timer overflow events are properly
* acknowledged */
BSP430_CORE_ENABLE_INTERRUPT();
while (1) {
unsigned long next_prep_utt;
char * obp;
char * ob_end;
next_prep_utt = ulBSP430uptime();
obp = tx_buffer_.buffer;
ob_end = obp + sizeof(tx_buffer_.buffer);
obp += snprintf(obp, ob_end - obp, "prep %lu emit %lu\r\n", emit_utt - prep_utt, done_utt - emit_utt);
ob_end = obp;
BSP430_CORE_DISABLE_INTERRUPT();
emit_utt = ulBSP430uptime_ni();
prep_utt = next_prep_utt;
tx_buffer_.tail = 0;
tx_buffer_.head = obp - tx_buffer_.buffer;
vBSP430serialWakeupTransmit_ni(uart);
BSP430_CORE_LPM_ENTER_NI(LPM0_bits);
/* Expect tail == head otherwise should not have awoken */
done_utt = ulBSP430uptime();
}
}
void main ()
{
sBSP430halPORT * port_hal;
hBSP430halTIMER hal;
volatile sBSP430hplTIMER * hpl;
vBSP430platformInitialize_ni();
(void)iBSP430consoleInitialize();
cputchar('\n');
BSP430_CORE_DELAY_CYCLES(BSP430_CLOCK_NOMINAL_MCLK_HZ / 1000);
cprintf("\n\nsynccap " __DATE__ " " __TIME__ "\n");
cprintf("External input on %s.%u corresponds to %s.%u%c\n",
xBSP430portName(BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE),
bitToPin(BSP430_TIMER_CCACLK_CC1_PORT_BIT),
xBSP430timerName(BSP430_TIMER_CCACLK_PERIPH_HANDLE),
PORT_CCIDX,
'A' + (BSP430_TIMER_CCACLK_CC1_CCIS / CCIS0));
port_hal = hBSP430portLookup(BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE);
if (NULL == port_hal) {
cprintf("Port HAL not available\n");
return;
}
hal = hBSP430timerLookup(BSP430_TIMER_CCACLK_PERIPH_HANDLE);
if (NULL == hal) {
cprintf("Can't find timer\n");
return;
}
BSP430_PORT_HAL_HPL_DIR(port_hal) &= ~BSP430_TIMER_CCACLK_CC1_PORT_BIT;
BSP430_PORT_HAL_HPL_SEL(port_hal) |= BSP430_TIMER_CCACLK_CC1_PORT_BIT;
hpl = hal->hpl;
hpl->cctl[1] = CM_3 | BSP430_TIMER_CCACLK_CC1_CCIS | SCS | CAP | CCIE;
captured.last_cci = !!(hpl->cctl[1] & CCI);
BSP430_HAL_ISR_CALLBACK_LINK_NI(sBSP430halISRIndexedChainNode,
hal->cc_cbchain_ni[PORT_CCIDX],
captured.cb,
next_ni);
hpl->ctl = TASSEL_2 | MC_2 | TACLR | TAIE;
/* Need to enable interrupts so timer overflow events are properly
* acknowledged */
while (1) {
unsigned int ccr;
unsigned int cctl;
unsigned int count;
unsigned int errors;
int last_cci;
unsigned long event_tt;
BSP430_CORE_DISABLE_INTERRUPT();
do {
event_tt = captured.event_tt;
captured.event_tt = 0;
count = captured.count;
errors = captured.errors;
captured.count = 0;
captured.errors = 0;
last_cci = captured.last_cci;
cctl = hpl->cctl[PORT_CCIDX];
ccr = hpl->ccr[PORT_CCIDX];
hpl->cctl[PORT_CCIDX] &= ~COV;
} while (0);
BSP430_CORE_ENABLE_INTERRUPT();
cprintf("Up %lu ACLK ticks, timer %lu event %lx ccr %x cctl %04x\n"
"\tCCI %d SCCI %d COV %d ; recorded CCI %d ; count %u errors %d\n",
ulBSP430uptime(),
ulBSP430timerCounter(hal, NULL),
event_tt,
ccr,
cctl,
!!(cctl & CCI), !!(cctl & SCCI), !!(cctl & COV), last_cci, count, errors);
BSP430_CORE_DELAY_CYCLES(BSP430_CLOCK_NOMINAL_MCLK_HZ);
}
}
