uart.c

Go to the documentation of this file.

/*
 *  Copyright (c) 2008  Swedish Institute of Computer Science
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
/**
 * \file
 *
 * \brief
 *      Handles the control of the USART for communication with the ATmega1284p
 *      for sending commands.
 *
 * \author
 *      Mike Vidales mavida404@gmail.com
 *
 */

#include "uart.h"
#include "lcd.h"
#include "main.h"
#include "menu.h"
#include "beep.h"

/**
 *  \addtogroup lcd
 *  \{
*/

#define TIMEOUT (0xff)

/** \brief The RX circular buffer, for storing characters from serial port. */
tcirc_buf rxbuf;

/*---------------------------------------------------------------------------*/

/**
 *   \brief This will intialize the circular buffer head and tail of tcirc_buf struct.
 *
 *   \param cbuf Pointer to buffer to initialize.
*/
void
uart_init_circ_buf(tcirc_buf *cbuf)
{
    cbuf->head = cbuf->tail = 0;
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This will add a new character to the circular buffer.
 *
 *   \param cbuf Pointer to buffer where character will be stored.
 *   \param ch Character to store into buffer.
*/
void
uart_add_to_circ_buf(tcirc_buf *cbuf, uint8_t ch)
{
    /* Add char to buffer */
    uint8_t newhead = cbuf->head;
    newhead++;
    if (newhead >= BUFSIZE){
        newhead = 0;
    }
    if (newhead == cbuf->tail){
        /* Buffer full, quit it */
        return;
    }

    cbuf->buf[cbuf->head] = ch;
    cbuf->head = newhead;
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This will get a character from the buffer requested.
 *
 *   \param cbuf Pointer to buffer to get character from.
 *
 *   \return retval Return character from buffer.
*/
uint8_t
uart_get_from_circ_buf(tcirc_buf *cbuf)
{
    /* Get char from buffer. */
    /* Be sure to check first that there is a char in buffer. */
    uint8_t newtail = cbuf->tail;
    uint8_t retval = cbuf->buf[newtail];

    newtail++;
    if (newtail >= BUFSIZE){
        /* Rollover */
        newtail = 0;
    }
    cbuf->tail = newtail;

    return retval;
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This will clear the RX buffer.
*/
void
uart_clear_rx_buf(void)
{
    rxbuf.tail = rxbuf.head = 0;
}

/**
 *   \brief This will check for a character in the requested buffer.
 *
 *   \param cbuf Pointer to buffer to check for any characters.
 *
 *   \return True if buffer empty.
*/
uint8_t
uart_circ_buf_has_char(tcirc_buf *cbuf)
{
    /* Return true if buffer empty */
    return (cbuf->head != cbuf->tail);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This will convert a nibble to a hex value.
 *
 *   \param val Value to convert to hex.
 *
 *   \return val Converted hex value
*/
uint8_t
uip_ntohex(uint8_t val)
{
    /* Convert nibble to hex */
    if (val > 9){
        return val + 'A' - 10;
    }
    else{
        return val + '0';
    }
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief Convert integer to hex value.
 *
 *   \param val Value to convert to hex.
 *   \param str Location to store converted value.
*/
void
itohex(uint8_t val,char *str)
{
    *str++ = uip_ntohex(val >> 8);
    *str = uip_ntohex(val & 0x0f);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This will wait for a new character from the ATmega1284p and timeout
 *   if no new character is received.
 *
 *   \retval TIMEOUT Returns if timeout has occured.
 *   \return retval Character returned upon seeing rx_char_ready()
*/
uint8_t
uart_get_char_rx(void)
{
    /* Gets a serial char, and waits for timeout */
    uint32_t timex = 5000000;
    uint8_t retval;

    while (!rx_char_ready()){
        if (!timex--){
            /* Timeout, return timeout */
            return TIMEOUT;
        }
    }

    retval = uart_get_from_circ_buf(&rxbuf);
    return retval;
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief Initialize UART to 38400 Baud Rate and only
 *   enable UART for transmission.
*/
void
uart_init(void)
{
    /* For Mega3290P, enable the uart peripheral */
    PRR &= ~(1 << PRUSART0);

    uart_clear_rx_buf();
    /* 38400 baud @ 8 MHz internal RC oscillator (error = 0.2%) */
    UBRR0 = BAUD_RATE_38400;

    /* 8 bit character size, 1 stop bit and no parity mode */
    UCSR0C = ( 3 << UCSZ00);

    /* Enable RX,TX and RX interrupt on USART */
    UCSR0B = (1 << RXEN0)|(1 << TXEN0)|(1 << RXCIE0);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief Turn off UART for sleep mode.
*/
void
uart_deinit(void)
{
    /* Disable RX,TX and RX interrupt on USART */
    UCSR0B = 0;

    /* for Mega3290P, disable the uart peripheral */
    PRR |= (1 << PRUSART0);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief Send one byte over the uart. This is called to send binary commands.
 *
 *   \param byte The byte of data to send out the uart.
*/
void
uart_send_byte(uint8_t byte)
{
    /* Wait for last char to be gone... */
    while(!(UCSR0A & (1 << UDRE0)))
        ;
    UDR0 = byte;

    /* Clear the TXC bit to allow transmit complete test before sleep*/
    UCSR0A |=(1 << TXC0);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This is the USART RX complete interrupt.
*/
ISR
(USART_RX_vect)
{
    /* Get byte from serial port, put in Rx Buffer. */
    uint8_t retval;

    retval = UDR0;
    uart_add_to_circ_buf(&rxbuf, retval);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This function builds and sends a binary command frame to the
 *   ATmega1284p.
 *
 *   \param cmd Command to send.
 *   \param payload_length Length of data to be sent with command.
 *   \param payload Pointer to data to send.
*/
void
uart_serial_send_frame(uint8_t cmd, uint8_t payload_length, uint8_t *payload)
{
    /* Send a frame to 1284p */
    int8_t i;

    uart_send_byte(SOF_CHAR);
    uart_send_byte(payload_length);
    uart_send_byte(cmd);
    for (i=0;i<=payload_length-1;i++){
            uart_send_byte(payload[i]);
        }
    uart_send_byte(EOF_CHAR);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This displays a time out message to the user based on the parameter
 *   reason x.
 *
 *   \param x Reason for USART time out.
*/
void
uart_timeout_msg(uint8_t x)
{
    char str[20] = "TO     ";

    dectoascii(x, str+3);
    lcd_puts(str);
}

/*---------------------------------------------------------------------------*/

/**
 *   \brief This will receive a frame from the ATmega1284p and parse the incoming
 *   data.
 *
 *   If the incoming data is a binary command acknowledgement, then this will not
 *   parse any data. If the incoming data is test reports, the menu will store the
 *   data for end of test metrics.
 *
 *   \param wait_for_ack Flag used to wait for acknowledgement when receving a serial
 *   frame.
*/
void
uart_serial_rcv_frame(uint8_t wait_for_ack)
{
    /* Gets a serial frame, if any, and displays data appropriately */
    /* If wait_for_ack is true, this funtion will wait for serial chars. */
    volatile uint8_t ch;
    volatile uint8_t length;
    volatile uint8_t cmd;
    volatile uint8_t payload[20];
    uint16_t i;

    if (!wait_for_ack && !rx_char_ready()){
        return;
    }

    /* Check for SOF */
    ch = uart_get_char_rx();
    if (ch != SOF_CHAR){
        return uart_timeout_msg(1);
    }

    /* Turn on nose LED for activity indicator */
    led_on();

    /* Get length byte */
    ch = uart_get_char_rx();
    if (ch == TIMEOUT){
        return uart_timeout_msg(2);
    }
    /* Check for ACK Frame */
    if (ch >= 0x80){
        /* This is an ack frame, just get it and go away. */
        ch = uart_get_char_rx();
        if (ch != EOF_CHAR){
            uart_timeout_msg(3);
        }
        led_off();
        return;
    }

    length = ch;
    if (length > sizeof(payload)){
        /* invalid length */
        return;
    }

    /* Get cmd byte */
    ch = uart_get_char_rx();
    if (ch == TIMEOUT){
        return uart_timeout_msg(5);
    }
    cmd = ch;

    /* Get payload */
    for (i=0;i<length;i++){
        ch = uart_get_char_rx();
        if (ch == TIMEOUT){
            return uart_timeout_msg(i);
        }
        /* Save payload */
        payload[i] = ch;
    }

    /* Get EOF */
    ch = uart_get_char_rx();
    if (ch != EOF_CHAR){
        return uart_timeout_msg(7);
    }

    /* Process the received command */
    switch (cmd){
        case REPORT_PING:
            /*
             * This will update the lcd with the current ping status.
             * Store the sequence number away.
             */
            ping_response = payload[0];

            if(ping_response == 1){
                lcd_single_print_dig(ping_response, 3);
            }
            else if(ping_response == 2){
                lcd_single_print_dig(ping_response, 2);
            }
            else if(ping_response == 3){
                lcd_single_print_dig(ping_response, 1);
            }
            else if(ping_response == 4){
                lcd_single_print_dig(ping_response, 0);
            }

            timeout_flag = false;

            /* Beep on successful ping response. */
            lcd_symbol_set(LCD_SYMBOL_BELL);
            beep();
            lcd_symbol_clr(LCD_SYMBOL_BELL);
            break;
        case REPORT_TEXT_MSG:
            /* Copy text message to menu buffer and play ringtone */
            /* Prezero in case no string terminator in command */
            for (i=0;i<sizeof(top_menu_text);i++) top_menu_text[i]=0;
            memcpy(&top_menu_text,(char *)payload,sizeof(top_menu_text)-1);  //leave zero byte at end
            play_ringtone();
            break;
        case REPORT_PING_BEEP:
            lcd_symbol_set(LCD_SYMBOL_BELL);
            beep();
            lcd_symbol_clr(LCD_SYMBOL_BELL);
            break;
        case REPORT_WAKE:
            /* Indicates 1284 is awake*/
            break;
        default:
            break;
    }
    led_off();
}

/** \}   */