/* * * 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(); } }