unsigned int
uiBSP430tlvChecksum (const unsigned char * data,
size_t len)
{
#ifdef __MSP430_HAS_CRC__
BSP430_CORE_INTERRUPT_STATE_T istate;
unsigned int rv;
size_t i;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
CRCINIRES = 0xFFFF;
for (i = 0; i < len; ++i) {
/* @warning Reversed CRC not available on certain MCUs; see
* function description */
CRCDIRB_L = data[i];
}
rv = CRCINIRES;
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
#else /* __MSP430_HAS_CRC__ */
/* This implementation is appropriate for 2xx/4xx TLV structures. */
const unsigned int * sp = (unsigned int *) data;
const unsigned int * const ep = (unsigned int *)(data + len);
unsigned int crc = 0;
while (sp < ep) {
crc ^= *sp++;
}
return -crc;
#endif /* __MSP430_HAS_CRC__ */
}
int writeToAddress (hBSP430m25p m25p,
uint8_t cmd,
unsigned long addr,
const uint8_t * data,
unsigned int len)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
unsigned long t0;
unsigned long t1;
int rc;
int sr;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
if (0 != iBSP430m25pStrobeCommand_ni(m25p, BSP430_M25P_CMD_WREN)) {
rc = -1;
break;
}
if (0 != iBSP430m25pInitiateAddressCommand_ni(m25p, cmd, addr)) {
rc = -1;
break;
}
rc = iBSP430m25pCompleteTxRx_ni(m25p, data, len, 0, NULL);
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
t0 = ulBSP430uptime();
do {
sr = iBSP430m25pStatus(m25p);
} while ((0 <= sr) && (BSP430_M25P_SR_WIP & sr));
t1 = ulBSP430uptime();
cprintf("Write %d took %lu\n", len, t1 - t0);
return rc;
}
unsigned char
ucBSP430eventTagAllocate (const char * id)
{
BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
unsigned char rc = 0;
BSP430_CORE_DISABLE_INTERRUPT();
do {
sBSP430eventTagConfig * cp = xBSP430eventTagConfig_ + nBSP430eventTagConfig_;
if (0 == nBSP430eventTagConfig_) {
cp->id = "LostEventRecord";
++cp;
++nBSP430eventTagConfig_;
}
/* Spin here if creating the configuration would overflow the
* config array */
while (sizeof(xBSP430eventTagConfig_)/sizeof(*xBSP430eventTagConfig_) <= nBSP430eventTagConfig_) {
}
cp->id = id;
cp->seqno = 0;
rc = (cp - xBSP430eventTagConfig_);
++nBSP430eventTagConfig_;
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rc;
}
int
iBSP430eventTagGetRecords (sBSP430eventTagRecord * evts,
int len)
{
BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
int nevt = 0;
if (0 == len) {
return len;
}
BSP430_CORE_DISABLE_INTERRUPT();
do {
if (0 != event_lost_count) {
memset(evts, 0, sizeof(*evts));
evts->tag = ucBSP430eventTag_LostEventRecord;
evts->u.sz = event_lost_count;
event_lost_count = 0;
++nevt;
}
while ((nevt < len) && !EVENT_EMPTY()) {
evts[nevt++] = xBSP430eventRecord[event_tail];
EVENT_INCREMENT_PTR(event_tail);
}
if (!EVENT_EMPTY()) {
vBSP430eventFlagsSet_ni(uiBSP430eventFlag_EventRecord);
}
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return nevt;
}
static int
cmd_uptime (const char * argstr)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
cprintf("Up %s\n", xBSP430uptimeAsText_ni(ulBSP430uptime_ni()));
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return 0;
}
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
iBSP430consoleFlush (void)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rv;
if (! console_hal_) {
return 0;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = iBSP430consoleWaitForTxSpace_ni(-1);
vBSP430serialFlush_ni(console_hal_);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
int
vcprintf (const char * fmt, va_list ap)
{
int rv;
BSP430_CORE_INTERRUPT_STATE_T istate;
/* Fail fast if printing is disabled */
if (! console_hal_) {
return 0;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = vuprintf(emit_char_ni, fmt, ap);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
int
iBSP430usciClose (hBSP430halSERIAL hal)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rc;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
SERIAL_HAL_HPL(hal)->ctl1 = UCSWRST;
rc = iBSP430platformConfigurePeripheralPins_ni((tBSP430periphHandle)(uintptr_t)(SERIAL_HAL_HPL(hal)),
peripheralConfigFlag(SERIAL_HAL_HPL(hal)->ctl0),
0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rc;
}
int
cputs (const char * s)
{
int rv = 0;
hBSP430halSERIAL uart = console_hal_;
BSP430_CORE_INTERRUPT_STATE_T istate;
if (! uart) {
return 0;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = emit_text_ni(s, uart);
emit_char2_ni('\n', uart);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return 1+rv;
}
static
hBSP430halSERIAL
usciConfigure (hBSP430halSERIAL hal,
unsigned char ctl0_byte,
unsigned char ctl1_byte,
unsigned int brw,
int mctl)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
SERIAL_HAL_HPL(hal)->ctl1 = UCSWRST;
do {
int periph_config = peripheralConfigFlag(ctl0_byte);
if (0 != iBSP430platformConfigurePeripheralPins_ni(xBSP430periphFromHPL(SERIAL_HAL_HPL(hal)), periph_config, 1)) {
hal = NULL;
break;
}
SERIAL_HAL_HPL(hal)->ctl1 |= ctl1_byte;
SERIAL_HAL_HPL(hal)->ctl0 = ctl0_byte;
SERIAL_HAL_HPL(hal)->br0 = brw % 256;
SERIAL_HAL_HPL(hal)->br1 = brw / 256;
if (0 <= mctl) {
SERIAL_HAL_HPL(hal)->mctl = mctl;
}
/* Mark the hal active */
hal->num_rx = hal->num_tx = 0;
/* Attempt to release the device for use; if that failed, reset it
* and return an error */
if (0 != iBSP430usciSetHold_ni(hal, 0)) {
SERIAL_HAL_HPL(hal)->ctl1 = UCSWRST;
hal = NULL;
}
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return hal;
}
int readFromAddress (hBSP430m25p m25p,
unsigned long addr,
unsigned int len)
{
BSP430_CORE_INTERRUPT_STATE_T istate;
int rc = -1;
if (len > sizeof(buffer)) {
len = sizeof(buffer);
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
if (0 == iBSP430m25pInitiateAddressCommand_ni(m25p, BSP430_M25P_CMD_FAST_READ, addr)) {
rc = iBSP430m25pCompleteTxRx_ni(m25p, NULL, 0, len, buffer);
}
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rc;
}
int
iBSP430consoleDeconfigure (void)
{
int rv = 0;
BSP430_CORE_INTERRUPT_STATE_T istate;
if (! console_hal_) {
return rv;
}
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
rv = iBSP430serialClose(console_hal_);
#if BSP430_CONSOLE_RX_BUFFER_SIZE - 0
BSP430_HAL_ISR_CALLBACK_UNLINK_NI(sBSP430halISRVoidChainNode, console_hal_->rx_cbchain_ni, rx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_RX_BUFFER_SIZE */
#if BSP430_CONSOLE_TX_BUFFER_SIZE - 0
BSP430_HAL_ISR_CALLBACK_UNLINK_NI(sBSP430halISRVoidChainNode, console_hal_->tx_cbchain_ni, tx_buffer_.cb_node, next_ni);
#endif /* BSP430_CONSOLE_TX_BUFFER_SIZE */
console_hal_ = NULL;
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
static void
process_statistics (const struct sBSP430eventTagRecord * ep,
struct sExampleMuxAlarm * ap)
{
sStatistics st;
char as_text[BSP430_UPTIME_AS_TEXT_LENGTH];
unsigned long period_utt;
unsigned long duty_ppt;
int i;
BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
st = statistics_v;
memset((void *)&statistics_v, 0, sizeof(statistics_v));
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
period_utt = st.awake_utt + st.sleep_utt;
if (0 == period_utt) {
duty_ppt = 0;
} else {
duty_ppt = (1000 * st.awake_utt + (period_utt / 2)) / period_utt;
}
#if (USE_FULL_STATS - 0)
cprintf("%s : Sleep %u ; MUX ", xBSP430uptimeAsText(ep->timestamp_utt, as_text), st.sleep_ct);
for (i = 0; i < sizeof(st.counter)/sizeof(*st.counter); ++i) {
cprintf(" %u", st.counter[i]);
}
cprintf(" = intr %u ; duty %lu ppt\n", st.mux_intr_ct, duty_ppt);
cprintf("\tasleep %lu tck = %lu ms ; awake %lu tck = %lu ms\n",
st.sleep_utt, BSP430_UPTIME_UTT_TO_MS(st.sleep_utt),
st.awake_utt, BSP430_UPTIME_UTT_TO_MS(st.awake_utt));
#else /* USE_FULL_STATS */
(void)i;
(void)as_text;
cprintf("sleep %lu awake %lu ; duty %lu ppt\n",
st.sleep_utt, st.awake_utt, duty_ppt);
#endif /* USE_FULL_STATS */
}
unsigned int
uiBSP430eventFlagAllocate ()
{
static unsigned int event_flag_last;
unsigned int rv;
BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
unsigned long fv = event_flag_last;
if (! fv) {
fv = uiBSP430eventFlag_EventRecord;
}
fv <<= 1;
rv = fv;
while (! rv) {
}
event_flag_last = rv;
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
return rv;
}
void main ()
{
BSP430_CORE_INTERRUPT_STATE_T istate;
#if BSP430_MODULE_SYS - 0
unsigned long reset_causes = 0;
unsigned int reset_flags = 0;
#endif /* BSP430_MODULE_SYS */
#if BSP430_MODULE_SYS - 0
{
unsigned int sysrstiv;
/* Record all the reset causes */
while (0 != ((sysrstiv = uiBSP430sysSYSRSTGenerator_ni(&reset_flags)))) {
reset_causes |= 1UL << (sysrstiv / 2);
}
}
#endif /* BSP430_MODULE_SYS */
vBSP430platformInitialize_ni();
(void)iBSP430consoleInitialize();
#if BSP430_MODULE_SYS - 0
cprintf("System reset bitmask %lx; causes:\n", reset_causes);
{
int bit = 0;
while (bit < (8 * sizeof(reset_causes))) {
if (reset_causes & (1UL << bit)) {
cprintf("\t%s\n", xBSP430sysSYSRSTIVDescription(2*bit));
}
++bit;
}
}
cputtext_ni("System reset included:");
if (reset_flags) {
if (reset_flags & BSP430_SYS_FLAG_SYSRST_BOR) {
cputtext_ni(" BOR");
}
if (reset_flags & BSP430_SYS_FLAG_SYSRST_LPM5WU) {
cputtext_ni(" LPM5WU");
}
if (reset_flags & BSP430_SYS_FLAG_SYSRST_POR) {
cputtext_ni(" POR");
}
if (reset_flags & BSP430_SYS_FLAG_SYSRST_PUC) {
cputtext_ni(" PUC");
}
} else {
cputtext_ni(" no data");
}
cputchar_ni('\n');
#endif /* BSP430_MODULE_SYS */
BSP430_CORE_ENABLE_INTERRUPT();
memcpy(ivect, VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
dumpRegion("Cached vectors", ivect, VECTOR_LENGTH_BYTES);
dumpRegion("Vectors", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
BSP430_CORE_SAVE_INTERRUPT_STATE(istate);
BSP430_CORE_DISABLE_INTERRUPT();
do {
/* Note: You need to flush the console if you want to see the
* output now; otherwise it'll be printed once interrupt-driven
* transmission is re-enabled. */
iBSP430consoleFlush();
iBSP430consoleTransmitUseInterrupts_ni(0);
(void)iBSP430flashEraseSegment_ni((void*)0xFE00);
dumpRegion("Vectors with 0xFE00", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
(void)iBSP430flashEraseSegment_ni(VECTOR_OFFSET);
vBSP430ledSet(0, 1);
dumpRegion("Vectors as erased", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
memcpy(erased_ivect, VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
(void)iBSP430flashWriteData_ni(VECTOR_OFFSET, ivect, VECTOR_LENGTH_BYTES);
vBSP430ledSet(1, 1);
iBSP430consoleTransmitUseInterrupts_ni(1);
} while (0);
BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
dumpRegion("Erased Vectors", erased_ivect, VECTOR_LENGTH_BYTES);
dumpRegion("Restored Vectors", VECTOR_OFFSET, VECTOR_LENGTH_BYTES);
iBSP430consoleFlush();
}
