rs232.c

Go to the documentation of this file.

 
#include "user_config.h"
#include "rs232.h"
 
struct _uart uarts[UARTS];
 
void uart_rx_flush(uint8_t uart)
{
    if(uart >= UARTS)
        return;
 
    cli();
 
    uarts[uart].rx_count = 0;
    uarts[uart].rx_head = 0;
    uarts[uart].rx_tail = 0;
    uarts[uart].rx_flow = 0;
    uarts[uart].rx_error = 0;
 
    sei();
}
 
 
int uart0_getchar( void *f  __attribute__((unused)))
{
    return( uart_getchar(0) );
}
 
 
int uart0_putchar(int c, void *f  __attribute__((unused)))
{
    uart_putchar(c, 0);
    return(c);
}
 
 
uint16_t uart_ubr(uint32_t baud, int *u2x, uint32_t *actual)
{
    double div;
    uint32_t ubr_regi;
 
// Calculating Baud Rate
// (U2X = 0)
// BAUD = Fosc/(16*(UBRn+1))
// UBRn = Fosc/(16*Baud) -1
// (U2X = 1)
// BAUD = Fosc/(8*(UBRn+1))
// UBRn = Fosc/(8*Baud) -1
 
    *u2x = 1;
    div = 8;
    ubr_regi = round( ((double)F_CPU/(div*(double)baud)) - 1.0 );
 
// For lower baud rates use 16 divider if the UBRR register overflows
// URBRR register is only a 12 bit register!
    if(ubr_regi > 4095)
    {
        *u2x = 0;
        div = 16.0;
        ubr_regi = round( ((double)F_CPU/(div*(double)baud)) - 1.0 );
    }
//overflow, baud rate was too low - so we clip to maximum allowed
    if(ubr_regi > 4095)
        ubr_regi = 4095;
 
    *actual = ((double)F_CPU/(div*((double)(ubr_regi+1))));
 
    return(ubr_regi);
}
 
 
uint32_t uart_init(uint8_t uart, uint32_t baud)
{
    uint16_t ubr_register;
    uint32_t actual;
    int u2x = 0;
 
    if(uart >= UARTS)
        return(0);
 
    ubr_register = uart_ubr(baud,(int*)&u2x,(uint32_t *)&actual);
 
    if(uart == 0)                                 /* uart == 0( first serial ) */
    {
        uart_rx_flush(0);
 
        cli();
 
        GPIO_PIN_LATCH_HI(RX0);
        GPIO_PIN_LATCH_HI(TX0);
        GPIO_PIN_DIR_IN(RX0);
        GPIO_PIN_DIR_OUT(TX0);
 
        UCSR0B = (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
 
        if(u2x)
            UCSR0A = (1<<U2X0);
 
        UBRR0H = (uint8_t) 0xff & (ubr_register >> 8);
        UBRR0L = (uint8_t) 0xff & (ubr_register);
 
        sei();
 
//@brief see posix.c this attaches uart functions to putchar() and getchar()
        fdevopen((void *)uart0_putchar, (void *)uart0_getchar);
    }
#if UARTS > 1
    if(uart == 1)                                 /* uart == 0( first serial ) */
    {
        uart_rx_flush(1);
 
        cli();
 
        GPIO_PIN_LATCH_HI(RX1);
        GPIO_PIN_LATCH_HI(TX1);
        GPIO_PIN_DIR_IN(RX1);
        GPIO_PIN_DIR_OUT(TX1);
 
        UCSR1B = (1<<RXCIE1)|(1<<RXEN1)|(1<<TXEN1);
 
        if(u2x)
            UCSR1A = (1<<U2X1);
 
        UBRR1H = (uint8_t) 0xff & (ubr_register >> 8);
        UBRR1L = (uint8_t) 0xff & (ubr_register);
 
        sei();
 
//@brief see posix.c this attaches uart functions to putchar() and getchar()
        fdevopen((void *)uart1_putchar, (void *)uart1_getchar);
    }
#endif
    return(actual);
}
 
 
ISR(USART0_RX_vect)
{
    uart_rx_interrupt(0, UDR0);
}
 
 
#if UARTS > 1
ISR(USART1_RX_vect)
{
    uart_rx_interrupt(1, UDR1);
}
#endif
 
void uart_rx_interrupt(uint8_t uart, uint8_t data)
{
    if (uarts[uart].rx_count < RX_BUF_SIZE )
    {
// MG 10 June 2020 mask off bit 7
        uarts[uart].rx_buf[uarts[uart].rx_head++] = data & 0x7f;
        uarts[uart].rx_count++;
        if (uarts[uart].rx_head >= RX_BUF_SIZE )
            uarts[uart].rx_head = 0;
    }
    else                                          // Overflow
    {
        uarts[uart].rx_error |= RX_OVERFLOW;
    }
}
 
 
int uart_peek_tail(uint8_t uart)
{
    uint8_t c;
 
    if(uart >= UARTS)
        return(EOF);
 
    cli();
    c = uarts[uart].rx_buf[uarts[uart].rx_tail];
    sei();
    return (c & 0xff);
}
 
 
int uart_get_tail(uint8_t uart)
{
    uint8_t c;
 
    if (uart >= UARTS)
    {
        return(EOF);
    }
 
    while(uart_rx_count(uart) < 1)
        ;
 
    cli();
    c = uarts[uart].rx_buf[uarts[uart].rx_tail++];
    if (uarts[uart].rx_tail >= RX_BUF_SIZE)
        uarts[uart].rx_tail = 0;
    uarts[uart].rx_count--;
    sei();
 
    return (c & 0xff);
}
 
 
int uart_rx_count(uint8_t uart)
{
    int count;
 
    if(uart >= UARTS)
        return(EOF);
 
    cli();
 
    count = uarts[uart].rx_count;
 
    sei();
 
    return (count );
}
 
 
int uart_rx_byte(uint8_t uart)
{
    return( uart_get_tail(uart) & 0xff);
}
 
 
int uart_getchar(uint8_t uart)
{
    uint8_t c;
 
    if(uart >= UARTS)
        return(EOF);
#if 0
    while(1)
    {
        c = uart_rx_byte(uart);
        if(c == '\n')
            continue;
        break;
    }
    if(c == '\r')
        c = '\n';
#endif
    c = uart_rx_byte(uart);
    uart_tx_byte(c, uart);
    if(c == '\r')
    {
        c = '\n';
        uart_tx_byte(c, uart);
    }
//FIXME ECHO
    return (c);
}
 
 
int uart_tx_byte(int c, uint8_t uart)
{
    if(uart == 0)
    {
        while (!BIT_TST(UCSR0A, UDRE0))
            ;
        UDR0 = c & 0x7f;
        return(c);
    }
#ifdef UARTS > 1
    if(uart == 1)
    {
        while (!BIT_TST(UCSR1A, UDRE1))
            ;
        UDR1 = c & 0x7f;
        return(c);
    }
#endif
    return(EOF);
}
 
 
int uart_putchar(int c, int uart)
{
    uart_tx_byte(c, uart);
 
    if( c == '\n' )
        uart_tx_byte('\r', uart);
 
    return(c);
}
 
 
int uart_keyhit(uint8_t uart)
{
    return ( uart_rx_count( uart ) );
}
 
 
int uart_put(int c)
{
    return( uart0_putchar(c,0) );
}
 
 
int uart_get(void)
{
    return(uart0_getchar(0));
}
 
 
int get_line (char *buff, int len)
{
    int c;
    int i = 0;
 
    memset(buff,0,len);
    while(1)
    {
        c = uart_get() & 0x7f;
        uart_put(c);
        if (c == '\n' || c == '\r')
            break;
 
        if (c == '\b')
        {
            if(i > 0)
                i--;
            buff[i] = 0;
            continue;
        }
 
        if (i < (len - 1) )                       /* Visible chars */
        {
            buff[i++] = c;
        }
        else
        {
            break;
        }
    }
    buff[i++] = 0;
    uart_put('\n');
 
    return(strlen(buff));
}