/* *
* readline - get a line from stdin
* @prompt: the string to be written to stdout
*
* The readline() function will write the input string @prompt to
* stdout first. If the @prompt is NULL or the empty string,
* no prompt is issued.
*
* This function will keep on reading characters and saving them to buffer
* 'buf' until '\n' or '\r' is encountered.
*
* Note that, if the length of string that will be read is longer than
* buffer size, the end of string will be discarded.
*
* The readline() function returns the text of the line read. If some errors
* are happened, NULL is returned. The return value is a global variable,
* thus it should be copied before it is used.
* */
char *
readline(const char *prompt) {
if (prompt != NULL) {
cprintf("%s", prompt);
}
int i = 0, c;
while (1) {
c = getchar();
if (c < 0) {
return NULL;
}
else if (c >= ' ' && i < BUFSIZE - 1) {
cputchar(c);
buf[i ++] = c;
}
else if (c == '\b' && i > 0) {
cputchar(c);
i --;
}
else if (c == '\n' || c == '\r') {
cputchar(c);
buf[i] = '\0';
return buf;
}
}
}
char *
readline(const char *prompt)
{
int i, c, echoing;
if (prompt != NULL)
cprintf("%s", prompt);
i = 0;
echoing = (iscons(0) > 0);
while (1) {
c = getchar();
if (c < 0) {
cprintf("read error: %e\n", c);
return NULL;
} else if (c >= ' ' && i < BUFLEN-1) {
if (echoing)
cputchar(c);
buf[i++] = c;
} else if (c == '\b' && i > 0) {
if (echoing)
cputchar(c);
i--;
} else if (c == '\n' || c == '\r') {
if (echoing)
cputchar(c);
buf[i] = 0;
return buf;
}
}
}
void
vBSP430cliConsoleDisplayChain (struct sBSP430cliCommandLink * chain,
const char * argstr)
{
if (chain) {
struct sBSP430cliCommandLink * cp;
struct sBSP430cliCommandLink * rchain;
unsigned int nlinks = 0;
cp = rchain = xBSP430cliReverseChain(chain);
do {
if (cp->cmd) {
if (0 < nlinks++) {
cputchar(' ');
}
cprintf("%s", cp->cmd->key);
}
cp = cp->link;
} while (cp);
(void)xBSP430cliReverseChain(rchain);
}
if (argstr[0]) {
cprintf("(%s)", argstr);
}
}
int readline(char *buf, size_t buf_l, const char *prompt, ...)
{
static spinlock_t readline_lock = SPINLOCK_INITIALIZER_IRQSAVE;
int i, c, echoing, retval;
va_list ap;
spin_lock_irqsave(&readline_lock);
va_start(ap, prompt);
if (prompt != NULL)
vcprintf(prompt, ap);
va_end(ap);
i = 0;
echoing = iscons(0);
while (1) {
c = getchar();
if (c < 0) {
printk("read error: %e\n", c); /* %e! */
retval = i;
break;
} else if (c == '\b' || c == 0x7f) {
if (i > 0) {
if (echoing)
cputchar(c);
i--;
}
continue;
} else if (c == '\n' || c == '\r') {
/* sending a \n regardless, since the serial port gives us a \r for
* carriage returns. */
if (echoing)
cputchar('\n');
assert(i <= buf_l - 1); /* never write to buf_l - 1 til the end */
buf[i++] = c;
retval = i;
break;
} else if (c >= ' ' && i < buf_l - 1) {
if (echoing)
cputchar(c);
buf[i++] = c;
}
}
spin_unlock_irqsave(&readline_lock);
return retval;
}
static int
cmd_expand_ (sBSP430cliCommandLink * chain,
void * param,
const char * argstr,
size_t argstr_len)
{
cputtext("Expanded: ");
vBSP430cliConsoleDisplayChain(chain, argstr);
cputchar('\n');
return 0;
}
void print_regs(struct pushregs *regs)
{
int i;
for (i = 0; i < 30; i++) {
cprintf(" $");
printbase10(i+1);
cprintf("\t: ");
printhex(regs->reg_r[i]);
cputchar('\n');
}
}
static void
putch(int ch, int *cnt, char *nNum, int *nOverflow)
{
cputchar(ch);
(*cnt)++;
char tmpCh = *nNum;
*nNum = *nNum+1;
if(*nNum < tmpCh)
*nOverflow = 1;
}
void
cputs (textarea_t *area, const char *text)
{
int i;
for (i = 0; i < strlen (text); i++)
cputchar (area, text[i]);
if (area->autorefresh)
display_refresh (area->display);
}
void dumpMemory (const uint8_t * dp,
size_t len,
unsigned long base)
{
const uint8_t * const edp = dp + len;
const uint8_t * adp = dp;
while (dp < edp) {
if (0 == (base & 0x0F)) {
if (adp < dp) {
cprintf(" ");
while (adp < dp) {
cputchar(isprint(*adp) ? *adp : '.');
++adp;
}
}
adp = dp;
cprintf("\n%08lx ", base);
} else if (0 == (base & 0x07)) {
cputchar(' ');
}
cprintf(" %02x", *dp++);
++base;
}
if (adp < dp) {
while (base & 0x0F) {
if (0 == (base & 0x07)) {
cputchar(' ');
}
cprintf(" ");
++base;
}
cprintf(" ");
while (adp < dp) {
cputchar(isprint(*adp) ? *adp : '.');
++adp;
}
}
cputchar('\n');
}
int
iBSP430cliConsoleBufferProcessInput ()
{
int rv;
int c;
rv = 0;
if (NULL == cbEnd_) {
cbEnd_ = consoleBuffer_;
}
while (0 <= ((c = cgetchar()))) {
if (KEY_BS == c) {
if (cbEnd_ == consoleBuffer_) {
cputchar(KEY_BEL);
} else {
--cbEnd_;
cputtext("\b \b");
}
#if (configBSP430_CLI_COMMAND_COMPLETION - 0)
} else if (KEY_HT == c) {
rv |= eBSP430cliConsole_DO_COMPLETION;
break;
#endif /* configBSP430_CLI_COMMAND_COMPLETION */
} else if (KEY_ESC == c) {
rv |= eBSP430cliConsole_PROCESS_ESCAPE;
break;
} else if (KEY_FF == c) {
cputchar(c);
rv |= eBSP430cliConsole_REPAINT;
break;
} else if (KEY_CR == c) {
cputchar('\n');
rv |= eBSP430cliConsole_READY;
break;
} else if (KEY_KILL_LINE == c) {
cprintf("\e[%uD\e[K", (unsigned int)(cbEnd_ - consoleBuffer_));
cbEnd_ = consoleBuffer_;
*cbEnd_ = 0;
} else if (KEY_KILL_WORD == c) {
int
iBSP430cliConsoleDiagnostic (struct sBSP430cliCommandLink * chain,
enum eBSP430cliErrorType errtype,
const char * argstr,
size_t argstr_len)
{
const sBSP430cliCommand * cmds = chain->command_set;
switch (errtype) {
case eBSP430_CLI_ERR_Config:
cputtext("Command configuration error: ");
break;
case eBSP430_CLI_ERR_Missing:
cputtext("Expected something after: ");
if (chain->cmd) {
cmds = chain->cmd->child;
}
break;
case eBSP430_CLI_ERR_Unrecognized:
cputtext("Unrecognized: ");
break;
case eBSP430_CLI_ERR_MultiMatch:
cputtext("Ambiguous command: ");
break;
case eBSP430_CLI_ERR_Invalid:
cputtext("Invalid value: ");
break;
default:
cprintf("ERROR %u at: ", errtype);
break;
}
vBSP430cliConsoleDisplayChain(chain, argstr);
if ((0 != cmds)
&& ((eBSP430_CLI_ERR_MultiMatch == errtype)
|| (eBSP430_CLI_ERR_Missing == errtype)
|| (eBSP430_CLI_ERR_Unrecognized == errtype))) {
sBSP430cliMatchCallback cbs;
cprintf("\nCandidates:\n");
/* If the diagnostic is that something's missing or unrecognized,
* ignore whatever's there so it doesn't inappropriately filter
* out all the real candidates. */
if ((eBSP430_CLI_ERR_Missing == errtype)
|| (eBSP430_CLI_ERR_Unrecognized == errtype)) {
argstr_len = 0;
}
cbs.callback = display_cmd;
(void)iBSP430cliMatchCommand(cmds, argstr, argstr_len, 0, &cbs, 0, 0);
}
cputchar('\n');
return -(int)errtype;
}
static int
cmd_h234 (sBSP430cliCommandLink * chain,
void * param,
const char * argstr,
size_t argstr_len)
{
cputtext("Display: ");
vBSP430cliConsoleDisplayChain(chain, argstr);
if (0 == argstr_len) {
cputs("\nWTH are we fighting for? Walk!");
}
cputchar('\n');
return 0;
}
char *
readline(const char *prompt)
{
int i, c, echoing;
#if JOS_KERNEL
if (prompt != NULL)
cprintf("%s", prompt);
#else
if (prompt != NULL)
fprintf(1, "%s", prompt);
#endif
i = 0;
echoing = iscons(0);
while (1) {
c = getchar();
if (c < 0) {
if (c != -E_EOF)
cprintf("read error: %e\n", c);
return NULL;
} else if ((c == '\b' || c == '\x7f') && i > 0) {
if (echoing)
cputchar('\b');
i--;
} else if (c >= ' ' && i < BUFLEN-1) {
if (echoing)
cputchar(c);
buf[i++] = c;
} else if (c == '\n' || c == '\r') {
if (echoing)
cputchar('\n');
buf[i] = 0;
return buf;
}
}
}
/*
* cprintf_doit -- commfunc used to show the string
*/
int cprintf_doit(const char *fmt, va_list ap)
{
char buf1[BUFSIZE];
int n, c;
int i;
memset(buf1, 0, sizeof(buf1));
vsnprintf(buf1, sizeof(buf1), fmt, ap);
n = strlen(buf1);
for (i = 0; (c = buf1[i]); ++i)
if (cputchar(c) == -1)
return n;
fflush(stdout);
return n;
}
void
print_trapframe(struct trapframe *tf) {
PRINT_HEX("trapframe at ", tf);
print_regs(&tf->tf_regs);
PRINT_HEX(" $ra\t: ", tf->tf_ra);
PRINT_HEX(" BadVA\t: ", tf->tf_vaddr);
PRINT_HEX(" Status\t: ", tf->tf_status);
PRINT_HEX(" Cause\t: ", tf->tf_cause);
PRINT_HEX(" EPC\t: ", tf->tf_epc);
if (!trap_in_kernel(tf)) {
cprintf("Trap in usermode: ");
}else{
cprintf("Trap in kernel: ");
}
cprintf(trapname(GET_CAUSE_EXCODE(tf->tf_cause)));
cputchar('\n');
}
static int
cmd_quote (const char * argstr)
{
size_t arglen = strlen(argstr);
size_t len;
cprintf("Extracting text tokens from %u characters\n", arglen);
while (0 < arglen) {
const char * tp = xBSP430cliNextQToken(&argstr, &arglen, &len);
cprintf("%u-char token <", len);
while (len--) {
cputchar(*tp++);
}
cprintf(">\n");
}
return 0;
}
void fillrectangle(int x1, int y1, int x2, int y2, char ch, int fillcolor)
{
int i, j;
int tmp_fnt_color, tmp_bak_color;
if (x1 > x2) chg_num(&x1, &x2);
if (y1 > y2) chg_num(&y1, &y2);
getcolors(&tmp_fnt_color, &tmp_bak_color);
setcolor(tmp_fnt_color, fillcolor);
for (i = x1; i <= x2; ++i) {
gotoxy(x1+i-x1, y1);
for (j = y1; j <= y2; ++j)
cputchar(ch);
}
setcolor(tmp_fnt_color, tmp_bak_color);
gotoxy(x1, y1);
}
void main ()
{
int rv;
uBSP430eui64 eui64;
int i;
vBSP430platformInitialize_ni();
(void)iBSP430consoleInitialize();
cputs("\n\n\nEUI-64 Verification");
#if ! (BSP430_EUI64 - 0)
cputs("EUI-64 not supported by platform\n");
#else /* BSP430_EUI64 */
while (1) {
memset(&eui64, 0, sizeof(eui64));
rv = iBSP430eui64(&eui64);
cprintf("Request got %d: ", rv);
for (i = 0; i < sizeof(eui64.bytes); ++i) {
cprintf("%02x", eui64.bytes[i]);
}
cputchar('\n');
}
#endif /* BSP430_EUI64 */
}
static void SendResponse(PHttpContext ctx, const char *body, BOOL ok) {
/* send response status */
HANDLE hFile;
KeyValueNode *curr;
int content_size = strlen(htmlstart)+strlen(htmlend) + strlen(body);
char digits[32];
HeaderInsert(&ctx->respList, &ctx->connection->pool, "Content-Length",
PoolStrDup(&ctx->connection->pool, _itoa(content_size,digits,10)));
HeaderInsert(&ctx->respList, &ctx->connection->pool, "Content-Type", "text/html");
curr = ctx->respList.next;
cputs(ctx->connection, "HTTP/1.1 ");
if (ok) {
cputint(ctx->connection, 200);
cputs(ctx->connection, " OK\r\n");
}
else {
cputint(ctx->connection, 404);
cputs(ctx->connection, " NOT FOUND\r\n");
}
while (curr != &ctx->respList) {
cputs(ctx->connection,curr->key);
cputchar(ctx->connection, ':');
cputchar(ctx->connection, ' ');
cputs(ctx->connection,curr->value);
cputchar(ctx->connection, '\r');
cputchar(ctx->connection, '\n');
curr = curr->next;
}
cputchar(ctx->connection, '\r');
cputchar(ctx->connection, '\n');
cputs(ctx->connection, htmlstart);
cputs(ctx->connection, body);
cputs(ctx->connection, htmlend);
ConnectionFlushOut(ctx->connection);
}
void
cputbuf(const char* str, int len)
{
for (int i = 0; i < len; i++)
cputchar(str[i]);
}
void main ()
{
int rc;
unsigned long next_wake_utt;
unsigned long delta_wake_utt;
vBSP430platformInitialize_ni();
(void)iBSP430consoleInitialize();
cprintf("\n\nadc demo, " __DATE__ " " __TIME__ "\n");
delta_wake_utt = 2 * ulBSP430uptimeConversionFrequency_Hz();
rc = initializeADC();
cprintf("%s initialized, returned %d, ADC cal at %p, REF cal at %p\n",
#if defined(__MSP430_HAS_ADC10__)
"ADC10"
#elif defined(__MSP430_HAS_ADC10_A__)
"ADC10_A"
#elif defined(__MSP430_HAS_ADC10_B__)
"ADC10_B"
#elif defined(__MSP430_HAS_ADC10_B4__)
"ADC10_B (FR4xx)"
#elif defined(__MSP430_HAS_ADC12__)
"ADC12"
#elif defined(__MSP430_HAS_ADC12_B__)
"ADC12_B"
#elif defined(__MSP430_HAS_ADC12_PLUS__)
"ADC12_PLUS"
#endif /* ADC */
, rc, cal_adc, cal_ref);
#if HAVE_REF
if (cal_ref) {
cprintf("Reference factors:\n"
"\t" REF_1pX_STR "V %u (0x%04x)\n"
"\t2.0V %u (0x%04x)\n"
"\t2.5V %u (0x%04x)\n",
cal_ref->cal_adc_15vref_factor, cal_ref->cal_adc_15vref_factor,
cal_ref->cal_adc_20vref_factor, cal_ref->cal_adc_20vref_factor,
cal_ref->cal_adc_25vref_factor, cal_ref->cal_adc_25vref_factor);
}
#endif /* HAVE_REF */
if (cal_adc) {
cprintf("ADC gain factor %d (0x%04x), offset %d\n",
cal_adc->cal_adc_gain_factor, cal_adc->cal_adc_gain_factor,
cal_adc->cal_adc_offset);
cprintf("Temperature ranges:\n");
cprintf("\t" REF_1pX_STR "V T30 %u T85 %u\n", cal_adc->cal_adc_15t30, cal_adc->cal_adc_15t85);
#if BSP430_TLV_IS_5XX
cprintf("\t2.0V T30 %u T85 %u\n", cal_adc->cal_adc_20t30, cal_adc->cal_adc_20t85);
#endif /* BSP430_TLV_IS_5XX */
cprintf("\t2.5V T30 %u T85 %u\n", cal_adc->cal_adc_25t30, cal_adc->cal_adc_25t85);
}
cprintf("Vmid channel %u, Temp channel %u"
#ifdef INCH_AUX
", Aux channel %u"
#endif /* INCH_AUX */
"\n",
INCH_VMID / INCH_BASE, INCH_TEMP / INCH_BASE
#ifdef INCH_AUX
, INCH_AUX / INCH_BASE
#endif /* INCH_AUX */
);
next_wake_utt = ulBSP430uptime_ni();
while (1) {
char timestamp[BSP430_UPTIME_AS_TEXT_LENGTH];
static const int refv[] = { REF_1pX, REF_2p0, REF_2p5 };
static const char * const refv_str[] = { REF_1pX_STR, "2.0", "2.5" };
static const int const nrefv = sizeof(refv)/sizeof(*refv);
static const int inch[] = { INCH_TEMP,
INCH_VMID,
#if defined(INCH_AUX)
INCH_AUX,
#endif /* INCH_AUX */
};
static const int const ninch = sizeof(inch)/sizeof(*inch);
int valid = 0;
sSample sample[sizeof(refv)/sizeof(*refv)][sizeof(inch)/sizeof(*inch)];
int ri;
int ii;
#define VALID(_ri,_ii) ((1 << (_ii)) << ((_ri) * nrefv))
#define ANY_VALID(_ri) (((1 << nrefv)-1) << ((_ri) * nrefv))
for (ri = 0; ri < nrefv; ++ri) {
if (0 == setReferenceVoltage(refv[ri])) {
for (ii = 0; ii < ninch; ++ii) {
if (0 == getSample(sample[ri]+ii, refv[ri], inch[ii])) {
valid |= VALID(ri, ii);
}
}
}
}
cprintf("%s: valid %x", xBSP430uptimeAsText(ulBSP430uptime_ni(), timestamp), valid);
for (ri = 0; ri < nrefv; ++ri) {
if (valid & ANY_VALID(ri)) {
cprintf("\n\t%sV: ", refv_str[ri]);
for (ii = 0; ii < ninch; ++ii) {
if (VALID(ri, ii) & valid) {
if (INCH_TEMP == inch[ii]) {
displayTemperature(sample[ri] + ii);
} else if (INCH_VMID == inch[ii]) {
displayVmid(sample[ri] + ii);
} else {
displayVoltage(sample[ri] + ii);
}
}
}
}
}
cputchar('\n');
next_wake_utt += delta_wake_utt;
while (0 < lBSP430uptimeSleepUntil(next_wake_utt, LPM3_bits)) {
/* nop */
}
}
}
/**
* Write a formatted string to a printf context
*
* @v ctx Context
* @v fmt Format string
* @v args Arguments corresponding to the format string
* @ret len Length of formatted string
*/
size_t vcprintf ( struct printf_context *ctx, const char *fmt, va_list args ) {
int flags;
int width;
uint8_t *length;
char *ptr;
char tmp_buf[32]; /* 32 is enough for all numerical formats.
* Insane width fields could overflow this buffer. */
wchar_t *wptr;
/* Initialise context */
ctx->len = 0;
for ( ; *fmt ; fmt++ ) {
/* Pass through ordinary characters */
if ( *fmt != '%' ) {
cputchar ( ctx, *fmt );
continue;
}
fmt++;
/* Process flag characters */
flags = 0;
for ( ; ; fmt++ ) {
if ( *fmt == '#' ) {
flags |= ALT_FORM;
} else if ( *fmt == '0' ) {
flags |= ZPAD;
} else {
/* End of flag characters */
break;
}
}
/* Process field width */
width = 0;
for ( ; ; fmt++ ) {
if ( ( ( unsigned ) ( *fmt - '0' ) ) < 10 ) {
width = ( width * 10 ) + ( *fmt - '0' );
} else {
break;
}
}
/* We don't do floating point */
/* Process length modifier */
length = &type_sizes[INT_LEN];
for ( ; ; fmt++ ) {
if ( *fmt == 'h' ) {
length--;
} else if ( *fmt == 'l' ) {
length++;
} else if ( *fmt == 'z' ) {
length = &type_sizes[SIZE_T_LEN];
} else {
break;
}
}
/* Process conversion specifier */
ptr = tmp_buf + sizeof ( tmp_buf ) - 1;
*ptr = '\0';
wptr = NULL;
if ( *fmt == 'c' ) {
if ( length < &type_sizes[LONG_LEN] ) {
cputchar ( ctx, va_arg ( args, unsigned int ) );
} else {
wchar_t wc;
size_t len;
wc = va_arg ( args, wint_t );
len = wcrtomb ( tmp_buf, wc, NULL );
tmp_buf[len] = '\0';
ptr = tmp_buf;
}
} else if ( *fmt == 's' ) {
if ( length < &type_sizes[LONG_LEN] ) {
ptr = va_arg ( args, char * );
if ( ! ptr )
ptr = "<NULL>";
} else {
wptr = va_arg ( args, wchar_t * );
if ( ! wptr )
ptr = "<NULL>";
}
} else if ( *fmt == 'p' ) {
static uint64_t
sys_putc(uint64_t arg[]) {
int c = (int)arg[0];
cputchar(c);
return 0;
}
static void
putch(int ch, int *cnt)
{
cputchar(ch);
*cnt++;
}
void _main(void)
{
char Line[255] ;
char Chose ;
do
{
//2012: lock the interrupt
sys_disable_interrupt();
cprintf("\n");
cprintf("!!!!!!!!!!!!!!!!!!!!\n");
cprintf("!!!! MERGE SORT !!!!\n");
cprintf("!!!!!!!!!!!!!!!!!!!!\n");
cprintf("\n");
readline("Enter the number of elements: ", Line);
int NumOfElements = strtol(Line, NULL, 10) ;
int *Elements = malloc(sizeof(int) * NumOfElements) ;
cprintf("Chose the initialization method:\n") ;
cprintf("a) Ascending\n") ;
cprintf("b) Descending\n") ;
cprintf("c) Semi random\n");
cprintf("Select: ") ;
Chose = getchar() ;
cputchar(Chose);
cputchar('\n');
//2012: lock the interrupt
sys_enable_interrupt();
int i ;
switch (Chose)
{
case 'a':
InitializeAscending(Elements, NumOfElements);
break ;
case 'b':
InitializeDescending(Elements, NumOfElements);
break ;
case 'c':
InitializeSemiRandom(Elements, NumOfElements);
break ;
default:
InitializeSemiRandom(Elements, NumOfElements);
}
MSort(Elements, 1, NumOfElements);
cprintf("Sorting is Finished!!!!it'll be checked now....\n") ;
//PrintElements(Elements, NumOfElements);
uint32 Sorted = CheckSorted(Elements, NumOfElements);
if(Sorted == 0) panic("The array is NOT sorted correctly") ;
else
{
cprintf("===============================================\n") ;
cprintf("Congratulations!! The array is sorted correctly\n") ;
cprintf("===============================================\n\n") ;
}
free(Elements) ;
cprintf("Do you want to repeat (y/n): ") ;
Chose = getchar() ;
cputchar(Chose);
cputchar('\n');
} while (Chose == 'y');
}
void main ()
{
#if (BSP430_CONSOLE - 0)
const char * help;
unsigned long smclk_Hz;
unsigned long aclk_Hz;
#endif /* BSP430_CONSOLE */
/* First thing you do in main is configure the platform. */
vBSP430platformInitialize_ni();
/* If we support a console, dump out a bunch of configuration
* information. */
#if (BSP430_CONSOLE - 0)
(void)iBSP430consoleInitialize();
cputtext("\nclocks " __DATE__ " " __TIME__ "\n");
cputtext("\nBSP430_PLATFORM_BOOT_CONFIGURE_LFXT1: ");
cputu(BSP430_PLATFORM_BOOT_CONFIGURE_LFXT1, 10);
cputtext("\nBSP430_CLOCK_LFXT1_STABILIZATION_DELAY_CYCLES: ");
cputul(BSP430_CLOCK_LFXT1_STABILIZATION_DELAY_CYCLES, 10);
cputtext("\nBSP430_PLATFORM_BOOT_LFXT1_DELAY_SEC: ");
cputu(BSP430_PLATFORM_BOOT_LFXT1_DELAY_SEC, 10);
cputtext("\nBSP430_PLATFORM_BOOT_CONFIGURE_CLOCKS: ");
cputu(BSP430_PLATFORM_BOOT_CONFIGURE_CLOCKS, 10);
#if defined(__MSP430_HAS_BC2__)
#if (configBSP430_BC2_TRIM_TO_MCLK - 0)
cputtext("\nconfigBSP430_BC2_TRIM_TO_MCLK: 1");
#else /* configBSP430_BC2_TRIM_TO_MCLK */
cputtext("\nconfigBSP430_BC2_TRIM_TO_MCLK: 0");
#endif /* configBSP430_BC2_TRIM_TO_MCLK */
#if (BSP430_BC2_TRIM_TO_MCLK - 0)
cputtext("\nBSP430_BC2_TRIM_TO_MCLK: 1");
#else /* BSP430_BC2_TRIM_TO_MCLK */
cputtext("\nBSP430_BC2_TRIM_TO_MCLK: 0");
#endif /* BSP430_BC2_TRIM_TO_MCLK */
#endif /* BC2 */
#if defined(__MSP430_HAS_UCS__) || defined(__MSP430_HAS_UCS_RF__)
#if (configBSP430_UCS_TRIM_DCOCLKDIV - 0)
cputtext("\nconfigBSP430_UCS_TRIM_DCOCLKDIV: 1");
#else /* configBSP430_UCS_TRIM_DCOCLKDIV */
cputtext("\nconfigBSP430_UCS_TRIM_DCOCLKDIV: 0");
#endif /* configBSP430_UCS_TRIM_DCOCLKDIV */
#if (BSP430_UCS_TRIM_DCOCLKDIV - 0)
cputtext("\nBSP430_UCS_TRIM_DCOCLKDIV: 1");
#else /* BSP430_UCS_TRIM_DCOCLKDIV */
cputtext("\nBSP430_UCS_TRIM_DCOCLKDIV: 0");
#endif /* BSP430_UCS_TRIM_DCOCLKDIV */
#endif /* UCS */
cputtext("\nBSP430_CLOCK_PUC_MCLK_HZ: ");
cputul(BSP430_CLOCK_PUC_MCLK_HZ, 10);
cputtext("\nBSP430_CLOCK_NOMINAL_MCLK_HZ: ");
cputul(BSP430_CLOCK_NOMINAL_MCLK_HZ, 10);
cputtext("\nBSP430_CLOCK_LFXT1_IS_FAULTED_NI(): ");
cputu(BSP430_CLOCK_LFXT1_IS_FAULTED_NI(), 10);
cputtext("\nBSP430_CLOCK_NOMINAL_VLOCLK_HZ: ");
cputu(BSP430_CLOCK_NOMINAL_VLOCLK_HZ, 10);
cputtext("\nBSP430_CLOCK_NOMINAL_XT1CLK_HZ: ");
cputul(BSP430_CLOCK_NOMINAL_XT1CLK_HZ, 10);
#if defined(BSP430_CLOCK_NOMINAL_XT2CLK_HZ)
cputtext("\nBSP430_PLATFORM_BOOT_CONFIGURE_XT2: ");
cputu(BSP430_PLATFORM_BOOT_CONFIGURE_XT2, 10);
cputtext("\nBSP430_CLOCK_XT2_IS_FAULTED_NI(): ");
cputu(BSP430_CLOCK_XT2_IS_FAULTED_NI(), 10);
cputtext("\nBSP430_CLOCK_NOMINAL_XT2CLK_HZ: ");
cputul(BSP430_CLOCK_NOMINAL_XT2CLK_HZ, 10);
#endif /* BSP430_CLOCK_NOMINAL_XT2CLK_HZ */
cputtext("\nulBSP430clockMCLK_Hz_ni(): ");
cputul(ulBSP430clockMCLK_Hz_ni(), 10);
cputtext("\nBSP430_PLATFORM_BOOT_SMCLK_DIVIDING_SHIFT: ");
cputi(BSP430_PLATFORM_BOOT_SMCLK_DIVIDING_SHIFT, 10);
cputtext("\nulBSP430clockSMCLK_Hz_ni(): ");
smclk_Hz = ulBSP430clockSMCLK_Hz_ni();
cputul(smclk_Hz, 10);
cputtext("\nBSP430_PLATFORM_BOOT_ACLK_DIVIDING_SHIFT: ");
cputi(BSP430_PLATFORM_BOOT_ACLK_DIVIDING_SHIFT, 10);
cputtext("\nulBSP430clockACLK_Hz_ni(): ");
aclk_Hz = ulBSP430clockACLK_Hz_ni();
cputul(aclk_Hz, 10);
#if (BSP430_TIMER_CCACLK - 0)
if (1000000UL <= aclk_Hz) {
cputtext("\nUnable to use high-speed ACLK for differential timing of SMCLK");
} else {
do {
const unsigned int SAMPLE_PERIOD_ACLK = 10;
volatile sBSP430hplTIMER * tp = xBSP430hplLookupTIMER(BSP430_TIMER_CCACLK_PERIPH_HANDLE);
unsigned int cc_delta;
unsigned long aclk_rel_smclk_Hz;
unsigned long smclk_rel_aclk_Hz;
if (! tp) {
cputtext("\nUnable to access configured CCACLK timer");
break;
}
/* Capture the SMCLK ticks between adjacent ACLK ticks */
tp->ctl = TASSEL_2 | MC_2 | TACLR;
cc_delta = uiBSP430timerCaptureDelta_ni(BSP430_TIMER_CCACLK_PERIPH_HANDLE,
BSP430_TIMER_CCACLK_ACLK_CCIDX,
CM_2,
BSP430_TIMER_CCACLK_ACLK_CCIS,
SAMPLE_PERIOD_ACLK);
tp->ctl = 0;
if (-1 == cc_delta) {
cputtext("\nCCACLK measurement failed");
break;
}
cputchar('\n');
cputu(SAMPLE_PERIOD_ACLK, 10);
cputtext(" ticks of ACLK produced ");
cputu(cc_delta, 10);
cputtext(" ticks of SMCLK");
cputtext("\nComparison with measured values:");
cputtext("\n SMCLK (Hz) (if measured ACLK correct): ");
smclk_rel_aclk_Hz = (cc_delta * aclk_Hz) / SAMPLE_PERIOD_ACLK;
cputul(smclk_rel_aclk_Hz, 10);
cputtext(" (error ");
cputl(smclk_rel_aclk_Hz - smclk_Hz, 10);
cputtext(" = ");
cputl(1000 * labs(smclk_rel_aclk_Hz - smclk_Hz) / smclk_Hz, 10);
cputtext(" kHz/MHz)");
cputtext("\n ACLK (Hz) (if measured SMCLK correct): ");
aclk_rel_smclk_Hz = SAMPLE_PERIOD_ACLK * smclk_Hz / cc_delta;
cputul(aclk_rel_smclk_Hz, 10);
cputtext(" (error ");
cputl(aclk_rel_smclk_Hz - aclk_Hz, 10);
cputtext(" = ");
cputl(1000 * labs(aclk_rel_smclk_Hz - aclk_Hz) / aclk_Hz, 10);
cputtext(" Hz/kHz)");
} while (0);
}
#else /* BSP430_TIMER_CCACLK */
cputtext("\nNo CCACLK timer available for ACLK/SMCLK comparison");
#endif /* BSP430_TIMER_CCACLK */
cputchar('\n');
#if defined(__MSP430_HAS_BC2__)
cputtext("\nBC2: DCO ");
cputu(DCOCTL, 16);
cputtext(" CTL1 ");
cputu(BCSCTL1, 16);
cputtext(" CTL2 ");
cputu(BCSCTL2, 16);
cputtext(" CTL3 ");
cputu(BCSCTL3, 16);
#endif
#if defined(__MSP430_HAS_FLL__) || defined(__MSP430_HAS_FLLPLUS__)
cprintf("\nFLL: SCF QCTL %02x I0 %02x I1 %02x ; CTL0 %02x CTL1 %02x CTL2 %02x\n",
SCFQCTL, SCFI0, SCFI1, FLL_CTL0, FLL_CTL1,
#if defined(FLL_CTL2_)
FLL_CTL2
#else /* FLL_CTL2 */
~0
#endif /* FLL_CTL2 */
);
#endif /* FLL/PLUS */
#if defined(__MSP430_HAS_UCS__) || defined(__MSP430_HAS_UCS_RF__)
cputtext("\nBSP430_UCS_FLL_SELREF: "
#if SELREF__XT2CLK <= BSP430_UCS_FLL_SELREF
"XT2CLK"
#elif SELREF__REFOCLK <= BSP430_UCS_FLL_SELREF
"REFOCLK"
#else /* BSP430_UCS_FLL_SELREF */
"XT1CLK"
#endif /* BSP430_UCS_FLL_SELREF */
);
cprintf("\nUCS RSEL %d DCO %d MOD %d:"
"\n CTL0 %04x CTL1 %04x CTL2 %04x CTL3 %04x"
"\n CTL4 %04x CTL5 %04x CTL6 %04x CTL7 %04x",
0x1F & (UCSCTL1 / DCORSEL0), 0x1F & (UCSCTL0 / DCO0), 0x1F & (UCSCTL0 / MOD0),
UCSCTL0, UCSCTL1, UCSCTL2, UCSCTL3,
UCSCTL4, UCSCTL5, UCSCTL6, UCSCTL7);
#endif /* UCS */
#if defined(__MSP430_HAS_CS__) || defined(__MSP430_HAS_CS_A__)
cprintf("\nCS %s : RSEL %d DCOFSEL %d:"
"\n CTL0 %04x CTL1 %04x CTL2 %04x CTL3 %04x"
"\n CTL4 %04x CTL5 %04x CTL6 %04x"
"\n FRCTL0 %04x",
#if (BSP430_CS_IS_FR57XX - 0)
"FR57xx"
#endif
#if (BSP430_CS_IS_FR58XX - 0)
"FR58xx"
#endif
"", !!(DCORSEL & CSCTL1), 0x07 & (CSCTL1 / DCOFSEL0),
CSCTL0, CSCTL1, CSCTL2, CSCTL3,
CSCTL4, CSCTL5, CSCTL6, FRCTL0);
#endif /* CS */
#endif /* BSP430_CONSOLE */
if (0 == iBSP430platformConfigurePeripheralPins_ni(BSP430_PERIPH_EXPOSED_CLOCKS, 0, 1)) {
#if (BSP430_CONSOLE - 0)
cputtext("\n\nClock signals exposed:\n ");
help = NULL;
#ifdef BSP430_PLATFORM_PERIPHERAL_HELP
help = xBSP430platformPeripheralHelp(BSP430_PERIPH_EXPOSED_CLOCKS, 0);
#endif /* BSP430_PLATFORM_PERIPHERAL_HELP */
if (NULL == help) {
help = "Go look at the data sheet and source, because nobody told me where they are";
}
cputtext(help);
cputtext("\nStatus register LPM bits: ");
cputu(__read_status_register() & BSP430_CORE_LPM_SR_MASK, 16);
cputtext("\nIFG1 bits: ");
#if defined(__MSP430_HAS_MSP430XV2_CPU__)
cputu(SFRIFG1, 16);
#else /* CPUX */
cputu(IFG1, 16);
#endif /* CPUX */
cputtext(" with OFIFG ");
cputu(OFIFG, 16);
cputchar('\n');
#endif /* BSP430_CONSOLE */
/* Spin here with CPU active. In LPM0, MCLK is disabled. Other
* clocks get disabled at deeper sleep modes; if you fall off the
* bottom, you might end up in LPM4 with all clocks disabled. */
while (1) {
vBSP430ledSet(0, -1);
BSP430_CORE_WATCHDOG_CLEAR();
BSP430_CORE_DELAY_CYCLES(BSP430_CLOCK_NOMINAL_MCLK_HZ / 2);
}
} else {
#if (BSP430_CONSOLE - 0)
cputtext("\nFailed to expose clock signals\n");
#endif /* BSP430_CONSOLE */
}
}
static int
sys_putc(uint32_t arg[]) {
int c = (int)arg[0];
cputchar(c);
return 0;
}
void main ()
{
hBSP430timerMuxSharedAlarm map;
tBSP430periphHandle uptime_periph;
int arc[sizeof(mux_alarms)/sizeof(*mux_alarms)];
unsigned long last_wake_utt;
unsigned long last_sleep_utt;
int rc = 0;
vBSP430platformInitialize_ni();
last_wake_utt = ulBSP430uptime_ni();
(void)iBSP430consoleInitialize();
BSP430_CORE_ENABLE_INTERRUPT();
cprintf("\n\nevent demo " __DATE__ " " __TIME__ "\n");
mux_tag = ucBSP430eventTagAllocate("MuxAlarm");
stats_tag = ucBSP430eventTagAllocate("Statistics");
mux_flag = uiBSP430eventFlagAllocate();
uptime_periph = xBSP430periphFromHPL(hBSP430uptimeTimer()->hpl);
map = hBSP430timerMuxAlarmStartup(&mux_alarm_base, uptime_periph, UPTIME_MUXALARM_CCIDX);
cprintf("Mux tag %u, stats tag %u, flag %x, with alarm base %p on %s.%u\n",
mux_tag, stats_tag, mux_flag, map,
xBSP430timerName(uptime_periph), UPTIME_MUXALARM_CCIDX);
if (! map) {
cprintf("ERR initializing mux shared alarm\n");
goto err_out;
}
/* Processing done entirely in mux callback. No wakeup. */
mux_alarms[0].alarm.callback_ni = mux_alarm_callback;
mux_alarms[0].interval_utt = BSP430_UPTIME_MS_TO_UTT(150);
/* Processing done by an event flag */
mux_alarms[1].alarm.callback_ni = mux_alarm_callback;
mux_alarms[1].interval_utt = BSP430_UPTIME_MS_TO_UTT(500);
mux_alarms[1].flag = mux_flag;
/* Processing done by a callback with a timestamped event */
mux_alarms[2].alarm.callback_ni = mux_alarm_callback;
mux_alarms[2].interval_utt = BSP430_UPTIME_MS_TO_UTT(700);
mux_alarms[2].process_fn = process_timestamp;
mux_alarms[2].tag = mux_tag;
/* Processing done by a callback with a timestamped event */
mux_alarms[3].alarm.callback_ni = mux_alarm_callback;
mux_alarms[3].interval_utt = BSP430_UPTIME_MS_TO_UTT(10000);
mux_alarms[3].process_fn = process_statistics;
mux_alarms[3].tag = stats_tag;
/* Enable the multiplexed alarms */
BSP430_CORE_DISABLE_INTERRUPT();
do {
int i = 0;
for (i = 0; (0 == rc) && (i < sizeof(mux_alarms)/sizeof(*mux_alarms)); ++i) {
mux_alarms[i].alarm.setting_tck = ulBSP430uptime_ni();
arc[i] = iBSP430timerMuxAlarmAdd_ni(map, &mux_alarms[i].alarm);
}
} while (0);
BSP430_CORE_ENABLE_INTERRUPT();
/* Display the results. All values should be non-negative for success. */
{
int i;
cprintf("Alarm installation got:");
rc = 0;
for (i = 0; i < sizeof(arc)/sizeof(*arc); ++i) {
cprintf(" %d", arc[i]);
if (0 > arc[i]) {
rc = arc[i];
}
}
cputchar('\n');
}
if (0 > rc) {
goto err_out;
}
last_sleep_utt = ulBSP430uptime();
while (1) {
last_wake_utt = ulBSP430uptime();
unsigned int events = process_events(uiBSP430eventFlagsGet());
if (events) {
cprintf("ERR: Unprocessed event flags %04x\n", events);
}
BSP430_CORE_DISABLE_INTERRUPT();
/* Put back any unprocessed events */
vBSP430eventFlagsSet_ni(events);
if (iBSP430eventFlagsEmpty_ni()) {
/* Nothing pending: go to sleep, then jump back to the loop head
* when we get woken. */
statistics_v.sleep_utt += last_wake_utt - last_sleep_utt;
last_sleep_utt = ulBSP430uptime_ni();
statistics_v.awake_utt += last_sleep_utt - last_wake_utt;
statistics_v.sleep_ct += 1;
BSP430_CORE_LPM_ENTER_NI(LPM4_bits | GIE);
continue;
}
BSP430_CORE_ENABLE_INTERRUPT();
}
err_out:
(void)iBSP430consoleFlush();
return;
}
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);
}
}
void main ()
{
const char * command;
int flags;
vBSP430platformInitialize_ni();
(void)iBSP430consoleInitialize();
vBSP430cliSetDiagnosticFunction(iBSP430cliConsoleDiagnostic);
cprintf("\ncli example " __DATE__ " " __TIME__ "\n");
#if configBSP430_CLI_COMMAND_COMPLETION - 0
cprintf("Command completion is available.\n");
#endif /* configBSP430_CLI_COMMAND_COMPLETION */
vBSP430ledSet(0, 1);
cprintf("\nLED lit when not awaiting input\n");
/* NOTE: The control flow in this is a bit tricky, as we're trying
* to leave interrupts enabled during the main body of the loop,
* while they must be disabled when processing input to recognize a
* command. The flags variable preserves state across multiple loop
* iterations until all relevant activities have completed. */
commandSet = LAST_COMMAND;
command = NULL;
flags = eBSP430cliConsole_REPAINT;
BSP430_CORE_ENABLE_INTERRUPT();
while (1) {
if (flags & eBSP430cliConsole_ANY_ESCAPE) {
int c;
while (0 <= ((c = cgetchar()))) {
cprintf("escape char 0x%02x (%u) '%c'\n", c, c, isprint(c) ? c : '.');
/* Technically CSI is a single character 0x9b representing
* ESC+[. In the two-character mode accepted here, we use the
* value for the second character. */
#define KEY_CSI '['
if ((KEY_CSI == c) && (flags & eBSP430cliConsole_PROCESS_ESCAPE)) {
flags &= ~eBSP430cliConsole_PROCESS_ESCAPE;
flags |= eBSP430cliConsole_IN_ESCAPE;
} else if ((64 <= c) && (c <= 126)) {
flags &= ~eBSP430cliConsole_ANY_ESCAPE;
cprintf("Leaving escape mode\n");
break;
}
}
}
if (flags & eBSP430cliConsole_DO_COMPLETION) {
flags &= ~eBSP430cliConsole_DO_COMPLETION;
flags |= iBSP430cliConsoleBufferCompletion(commandSet, &command);
}
if (flags & eBSP430cliConsole_READY) {
int rv;
rv = iBSP430cliExecuteCommand(commandSet, 0, command);
if (0 != rv) {
cprintf("Command execution returned %d\n", rv);
}
/* Ensure prompt is rewritten, but not the command we just
* ran */
flags |= eBSP430cliConsole_REPAINT;
command = NULL;
}
if (flags & eBSP430cliConsole_REPAINT) {
/* Draw the prompt along with whatever's left in the command
* buffer. Note use of leading carriage return in case an edit
* left material on the current line. */
cprintf("\r> %s", command ? command : "");
flags &= ~eBSP430cliConsole_REPAINT;
}
if (flags & eBSP430cliConsole_REPAINT_BEL) {
cputchar('\a');
flags &= ~eBSP430cliConsole_REPAINT_BEL;
}
BSP430_CORE_DISABLE_INTERRUPT();
do {
if (flags & eBSP430cliConsole_READY) {
/* Clear the command we just completed */
vBSP430cliConsoleBufferClear_ni();
flags &= ~eBSP430cliConsole_READY;
}
do {
/* Unless we're processing application-specific escape
* characters let iBSP430cliConsoleBufferProcessInput_ni()
* process any input characters that have already been
* received. */
if (! (flags & eBSP430cliConsole_ANY_ESCAPE)) {
flags |= iBSP430cliConsoleBufferProcessInput_ni();
}
if (0 == flags) {
/* Sleep until something wakes us, such as console input.
* Then turn off interrupts and loop back to read that
* input. */
vBSP430ledSet(0, 0);
BSP430_CORE_LPM_ENTER_NI(LPM0_bits);
BSP430_CORE_DISABLE_INTERRUPT();
vBSP430ledSet(0, 1);
}
/* Repeat if still nothing to do */
} while (! flags);
/* Got something to do; get the command contents in place so
* we can update the screen. */
command = xBSP430cliConsoleBuffer_ni();
} while (0);
BSP430_CORE_ENABLE_INTERRUPT();
}
}
