usarts.h

Go to the documentation of this file.

/* usart interface header file */
/* Copyright (C) 2009 Holger Dietze
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) version 3.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License along
 *   with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#ifndef USARTS_H
#define USARTS_H

#include <stdint.h>
#include <avr/pgmspace.h>
#include <avr/io.h>

#include "fifo.h"

/* USART_FRAME_ERROR and USART_PARITY_ERROR intentionally have
 * the same values as _BV(FE0) and _BV(UPE0) in UCSRnA. This
 * gives simpler machine code in the interrupt function. */
#define USART_FRAME_ERROR (1<<4)

#define USART_PARITY_ERROR (1<<2)

#define USART_NO_RX (1<<7)

#define USART_TIMESTAMPED (1<<6)

typedef uint32_t baudrate_t;

typedef struct usart_rxdata_s {
  uint8_t data;
  uint8_t flags;
} usart_rxdata_t;

typedef uint8_t usart_timestamp_t;

typedef struct usart_control_s {
  volatile uint8_t * const base;
  fifo_t txbuf;
  fifo_t rxbuf;
  volatile uint8_t * const prr;
  uint8_t const prusart; /* bit mask */
  volatile uint8_t tx_empty;
  uint8_t ts_trigger;
  usart_timestamp_t timestamp;
  const char * const name;
} usart_control_t;

typedef enum {
  usart_ext, 
  usart_mod, 
  USARTS_NUMBER,
  usart_none = -1,
} hlog_usart_t;

/* \brief initialize USART
 *
 * initializes one usart_control_s structure and powers up the
 * USART and, if applicable, the level converter.
 * \param which selects which USART to use
 * \param txbuf pointer to a FIFO buffer used for sending
 * \param txsize size of txbuf
 * \param rxbuf pointer to a FIFO buffer used for receiving
 * \param rxsize size of rxbuf
 * \return pointer to the usart_control_t structure used for the selected
 *         USART
 *
 * If txbuf is NULL, the USART will not be available for sending.
 * If rxbuf is NULL, the USART will not be available for receiving.
 * 
 * There will be one and only one usart_control_s structure for
 * each usable USART.
 */
usart_control_t * usart_init (hlog_usart_t which,
                              fifo_item_t * txbuf, fifo_size_t txsize,
                              fifo_item_t * rxbuf, fifo_size_t rxsize);

baudrate_t usart_set_baudrate (usart_control_t * uc, baudrate_t baud);

baudrate_t usart_change_baudrate (usart_control_t * uc, int8_t incdec);

void usart_disable (usart_control_t *);
void usart_power (usart_control_t *, uint8_t onoff);

void usart_enable (usart_control_t * uc);

usart_rxdata_t usart_recv (usart_control_t * uc);

inline uint8_t usart_can_recv (usart_control_t * uc)
{
  return fifo_get_buffer (&uc->rxbuf) && !fifo_is_empty(&uc->rxbuf);
}

void usart_send (usart_control_t * uc, uint8_t b);

void usart_flush (usart_control_t *uc);

uint8_t usart_ext_is_connected (void);

inline uint8_t usart_can_send (usart_control_t * uc)
{
  return fifo_get_buffer (&uc->txbuf) && !fifo_is_full(&uc->txbuf);
}

inline size_t usart_send_msg (usart_control_t * uc, uint8_t nonblock,
                              const uint8_t * msg, const size_t msglen)
{
  size_t cnt = msglen;
  if (cnt)
    do {
      if (nonblock && !usart_can_send (uc))
        break;
      usart_send (uc, *msg++);
    } while (--cnt);
  return msglen - cnt;
}

inline size_t usart_send_msg_P (usart_control_t * uc, uint8_t nonblock,
                              const uint8_t * msg, const size_t msglen)
{
  size_t cnt = msglen;
  if (cnt)
    do {
      if (nonblock && !usart_can_send (uc))
        break;
      usart_send (uc, pgm_read_byte (msg++));
    } while (--cnt);
  return msglen - cnt;
}

inline void usart_timestamp_set_trigger (usart_control_t * uc, uint8_t trigger)
{
  uc->ts_trigger = trigger;
}

inline usart_timestamp_t usart_get_timestamp (usart_control_t * uc)
{
  return uc->timestamp;
}

#endif