int usart_putc2(char c, FILE *stream)
{
if (c == '\n')
usart_putc('\r');
usart_putc(c);
return 0;
}
void usart_puti(USART_INTEGER n)
{
char str[10]; // Maximum length of string is 10
int i = 0, j;
#ifdef USART_SIGNED_SUPPORT
if(n < 0){
usart_putc('-');
n = -n;
}
#endif
while (n > 0) {
str[i++] = n % 10 + '0';
n /= 10;
}
for (j = i - 1; 0 <= j; j--) {
usart_putc(str[j]);
}
if (i == 0) {
usart_putc('0');
}
}
/* (Called from exc.S with global interrupts disabled.) */
void __error(int num) {
nvic_globalirq_enable();
usart_putstr(ERROR_USART, "\r\nexception: ");
usart_putudec(ERROR_USART, num);
usart_putc(ERROR_USART, '\n');
usart_putc(ERROR_USART, '\r');
for(;;);
throb();
/* Turn off peripheral interrupts */
nvic_irq_disable_all();
/* Turn off timers */
timer_disable_all();
/* Turn off ADC */
adc_disable_all();
/* Turn off all USARTs */
usart_disable_all();
/* Turn the USB interrupt back on so the bootloader keeps on functioning */
nvic_irq_enable(NVIC_USB_HP_CAN_TX);
nvic_irq_enable(NVIC_USB_LP_CAN_RX0);
/* Reenable global interrupts */
nvic_globalirq_enable();
throb();
}
void
IRQ_USART2(void)
{
char t = usart_getc(&usartcfg);
if (t == '\r')
usart_putc(&usartcfg, '\n');
usart_putc(&usartcfg, t);
}
void usart_puts(const char *ptr)
{
int i = 0;
while (ptr[i] != '\0') {
if (ptr[i] == '\n')
usart_putc('\r');
usart_putc(ptr[i]);
i++;
}
}
void usart_puts(char *data) {
int len, count;
len = strlen(data);
for (count = 0; count < len; count++)
usart_putc(*(data+count));
}
void usart_putstr_P(PGM_P str)
{
char ch;
while((ch = pgm_read_byte(str++)) != '\0') {
usart_putc(ch);
}
}
void usart_puts(char *dat)
{
do {
while( usart_busy() );
usart_putc( *dat );
} while( *dat++ );
}
unsigned int usart_write(const char* c, unsigned int length)
{
unsigned int written = 0;
for (unsigned int i=0; i<length; i++)
written += usart_putc(c[i]);
return written;
}
/**
* @brief Syscall for console write
*
* Used as an entry for newlib _write syscall. It automatically
* adds '\r' along with each '\n'. By default, put all
* characters to configured USART port.
*
* @param file File descriptor (unused)
* @param ptr Message pointer
* @param len Length of the buffer
*
* @return Number of characters successfully printed.
*/
int
_write(int file, char *ptr, int len)
{
int todo;
if (file) {};
for (todo = 0; todo < len; todo++) {
usart_putc(&usartcfg, *ptr);
/* Froce sending CR with new line */
if (*ptr == '\n')
usart_putc(&usartcfg, '\r');
ptr++;
}
return len;
}
unsigned int usart_print(const char* c)
{
unsigned int written = 0;
for (const char* i = c; *i != 0; i++)
written += usart_putc(*i);
return written;
}
/* usart_puts(char s[])
* Sends a string over the USART by repeatedly calling usart_putc()
*/
void usart_puts(const char s[]) {
int i = 0;
while(i < USART_TXBUFFERSIZE) // don't get stuck if it is a bad string
{
if( s[i] == '\0' ) break; // quit on string terminator
usart_putc(s[i++]);
}
}
/* usart_puts_p(const char *data)
* Sends strings stored in flash memory to the usart.
*/
void usart_puts_p(const char *data_ptr) {
uint8_t txdata = 1; // Dummy initialization value
while ( txdata != 0x00 ) {
txdata = pgm_read_byte(data_ptr);
usart_putc(txdata);
data_ptr++;
}
}
void usart_puthex(unsigned char ch)
{
unsigned char up = (ch >> 4) & 0xf;
unsigned char down = ch & 0xf;
if (up < 10) {
usart_putc(up + '0');
} else {
usart_putc(up + 'A' - 10);
}
if (down < 10) {
usart_putc(down + '0');
} else {
usart_putc(down + 'A' - 10);
}
}
// write a program-memory string to usart
void usart_print_pstr(PGM_P pstr) {
uint8_t i = 0;
char c = pgm_read_byte(&(pstr[i]));
while(c) {
usart_putc(c);
c = pgm_read_byte(&(pstr[++i]));
}
}
static void dbg_sync_putchar(char chr)
{
if (chr == '\n')
dbg_sync_putchar('\r');
usart_putc(&console_uart, chr);
while (!usart_status(&console_uart, USART_TC))
/* wait */ ;
}
static void
task_uart(void* unused)
{
/* Blink LED and print dot mark each iteration */
while (1) {
vTaskDelay(1000);
usart_putc(&usartcfg, '.');
}
}
/**
* @brief Print an error message on a UART upon a failed assertion
* and throb the error LED, if there is one defined.
* @param file Source file of failed assertion
* @param line Source line of failed assertion
* @param exp String representation of failed assertion
* @sideeffect Turns of all peripheral interrupts except USB.
*/
void _fail(const char* file, int line, const char* exp) {
/* Initialize the error USART */
gpio_set_mode(ERROR_TX_PORT, ERROR_TX_PIN, GPIO_AF_OUTPUT_PP);
usart_init(ERROR_USART);
usart_set_baud_rate(ERROR_USART, ERROR_USART_CLK_SPEED, ERROR_USART_BAUD);
/* Print failed assert message */
usart_putstr(ERROR_USART, "ERROR: FAILED ASSERT(");
usart_putstr(ERROR_USART, exp);
usart_putstr(ERROR_USART, "): ");
usart_putstr(ERROR_USART, file);
usart_putstr(ERROR_USART, ": ");
usart_putudec(ERROR_USART, line);
usart_putc(ERROR_USART, '\n');
usart_putc(ERROR_USART, '\r');
/* Error fade */
__error();
}
// print an integer to usart
void usart_print_int(int32_t n) {
if(n < 0) {
usart_putc('-');
n *= -1;
}
uint8_t print = 0;
for(uint32_t order = 1000000000UL; order; order /= 10) {
uint8_t digit = n / order;
if(print || digit) {
usart_putc('0' + digit);
print = 1;
}
n %= order;
}
if(!print) {
usart_putc('0');
}
}
void usart_printf(const char *ptr){
// Send NULL-terminated data from FLASH.
// Uses polling (and it blocks).
char c;
while(pgm_read_byte_near(ptr)) {
c = pgm_read_byte_near(ptr++);
usart_putc(c);
}
}
/** Write string. In non-blocking mode this is likely to
ignore all but the first character. */
int
usart_puts (usart_t usart, const char *str)
{
while (*str)
{
int ret;
ret = usart_putc (usart, *str++);
if (ret < 1)
return ret;
}
return 1;
}
/**
* @brief Transmit an unsigned integer to the specified serial port in
* decimal format.
*
* This function blocks until the integer's digits have been
* completely transmitted.
*
* @param dev Serial port to send on
* @param val Number to print
*/
void usart_putudec(usart_dev *dev, uint32 val) {
char digits[12];
int i = 0;
do {
digits[i++] = val % 10 + '0';
val /= 10;
} while (val > 0);
while (--i >= 0) {
usart_putc(dev, digits[i]);
}
}
// UART
void getDate(int *yy,int *mm, int*dd)
{
char temp[5];
int i;
do {
usart_prints("\nPlease Enter Year (yyyy):");
for (i = 0; i <= 4; i++)
{
temp[i] = usart_getc(); // Get character
usart_putc(temp[i]); // Echo it back
}
temp[i] = '\0';
sscanf(temp,"%d",yy);
} while(*yy < 2016 || *yy > 2020);
do {
usart_prints("\nPlease Enter Month (mm):");
for (i = 0; i <= 2; i++)
{
temp[i] = usart_getc(); // Get character
usart_putc(temp[i]); // Echo it back
}
temp[i] = '\0';
sscanf(temp,"%d",mm);
} while(*mm < 1 || *mm > 12);
do {
usart_prints("\nPlease Enter Day (dd):");
for (i = 0; i <= 2; i++)
{
temp[i] = usart_getc(); // Get character
usart_putc(temp[i]); // Echo it back
}
temp[i] = '\0';
sscanf(temp,"%d",dd);
} while(*dd < 1 || *dd > 31);
usart_prints("\n");
}
int usart_write(char *buf, size_t buflen)
{
int i;
int cnt = 0;
for (i=0; i < buflen; i++)
{
if (usart_putc(*(buf+i)) == -1)
break;
}
return cnt;
}
size_t usart_getstr_s(char* str, size_t len)
{
uint16_t i;
for (i = 0; i < len - 1; i++) {
char ch = usart_getc();
switch (ch) {
case '\r':
goto finish;
case 0x1b:
str -= i;
i = 0;
goto finish;
default:
usart_putc(ch);
*str++ = ch;
break;
}
}
finish: *str = 0;
usart_putc('\r');
usart_putc('\n');
return i;
}
static void dbg_async_putchar(char chr)
{
/* If UART is busy, try to put chr into queue until slot is freed,
* else write directly into UART
*/
if (!dbg_uart.ready) {
while (queue_push(&(dbg_uart.tx), chr) != QUEUE_OK)
/* wait */ ;
}
else {
usart_putc(&console_uart, chr);
dbg_uart.ready = 0;
usart_config_interrupt(&console_uart, USART_IT_TXE, 1);
}
}
int usart_puts(char *s, void *env) {
int total = 0;
while (*s) {
int ret = usart_putc(*s++, env);
if (ret > 0) {
total += ret;
}
else {
total = ret;
break;
}
}
return total;
}
static void dbg_uart_send(int avail)
{
uint8_t chr;
if (avail) {
if (!queue_is_empty(&(dbg_uart.tx))) {
queue_pop(&(dbg_uart.tx), &chr);
usart_putc(&console_uart, chr);
dbg_uart.ready = 0;
usart_config_interrupt(&console_uart, USART_IT_TXE, 1);
}
else {
dbg_uart.ready = 1;
usart_config_interrupt(&console_uart, USART_IT_TXE, 0);
}
}
}
static void setupUSART(usart_dev *dev, uint32 baud)
{
uint32 i = USART_RX_BUF_SIZE;
/* FIXME: need some preprocess here, according to specific board */
if (dev == USART1) {
gpio_set_mode(GPIOA, 9, GPIO_AF_OUTPUT_PP);
gpio_set_mode(GPIOA, 10, GPIO_INPUT_FLOATING);
}
usart_init(dev);
usart_set_baud_rate(dev, 72000000UL, baud);
usart_disable(dev);
usart_enable(dev);
/* flush buffer */
while (i--) {
usart_putc(dev, '\r');
}
}
int main(void) {
os_init();
os_semaphore_init(&lcd_sem, 1);
os_semaphore_init(&btn_sem, 1);
os_semaphore_init(&stt_sem, 1);
os_semaphore_init(&tck_sem, 1);
os_add_task(uart_task, &uart_task_stack[STACK_SIZE + 64], 1, "uart");
os_add_task(adc_task, &adc_task_stack[STACK_SIZE + 64], 0, "adc");
os_add_task(button_task, &button_task_stack[STACK_SIZE + 64], 2, "btn");
os_start_ticker();
os_semaphore_wait(&lcd_sem);
lcd_init();
os_semaphore_signal(&lcd_sem);
i2c_init();
usart_init(USART_TRANSMIT | USART_RECEIVE);
usart_putc('\f');
while(1) {
char buff[6];
os_delay(os_get_current_pid(), 2000);
/*usart_puts("Start I2C\r\n");
int8_t start_ = i2c_start();
int8_t send_ = i2c_send_address(0xa0);
i2c_stop();
if (start_ != 0) {
usart_puts("Start error\r\n");
uint8_t_to_ascii((uint8_t) start_, &(buff[0]));
usart_puts(buff);
usart_puts("\r\n");
}
if (send_ != 0) {
usart_puts("Send error\r\n");
uint8_t_to_ascii((uint8_t) send_, &(buff[0]));
usart_puts(buff);
usart_puts("\r\n");
}
usart_puts("Stop I2C\r\n\r\n");*/
}
return 0;
}
