projects/geeknamensschilder_c/hardware/cores/arduino/HardwareSerial.cpp

   1 /*
   2   HardwareSerial.cpp - Hardware serial library for Wiring
   3   Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
   4
   5   This library is free software; you can redistribute it and/or
   6   modify it under the terms of the GNU Lesser General Public
   7   License as published by the Free Software Foundation; either
   8   version 2.1 of the License, or (at your option) any later version.
   9
  10   This library is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13   Lesser General Public License for more details.
  14
  15   You should have received a copy of the GNU Lesser General Public
  16   License along with this library; if not, write to the Free Software
  17   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19   Modified 23 November 2006 by David A. Mellis
  20 */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <inttypes.h>
  25 #include "wiring.h"
  26 #include "wiring_private.h"
  27
  28 #include "HardwareSerial.h"
  29
  30 // Define constants and variables for buffering incoming serial data.  We're
  31 // using a ring buffer (I think), in which rx_buffer_head is the index of the
  32 // location to which to write the next incoming character and rx_buffer_tail
  33 // is the index of the location from which to read.
  34 #define RX_BUFFER_SIZE 128
  35
  36 struct ring_buffer {
  37   unsigned char buffer[RX_BUFFER_SIZE];
  38   int head;
  39   int tail;
  40 };
  41
  42 ring_buffer rx_buffer = { { 0 }, 0, 0 };
  43
  44 #if defined(__AVR_ATmega1280__)
  45 ring_buffer rx_buffer1 = { { 0 }, 0, 0 };
  46 ring_buffer rx_buffer2 = { { 0 }, 0, 0 };
  47 ring_buffer rx_buffer3 = { { 0 }, 0, 0 };
  48 #endif
  49
  50 inline void store_char(unsigned char c, ring_buffer *rx_buffer)
  51 {
  52   int i = (rx_buffer->head + 1) % RX_BUFFER_SIZE;
  53
  54   // if we should be storing the received character into the location
  55   // just before the tail (meaning that the head would advance to the
  56   // current location of the tail), we're about to overflow the buffer
  57   // and so we don't write the character or advance the head.
  58   if (i != rx_buffer->tail) {
  59     rx_buffer->buffer[rx_buffer->head] = c;
  60     rx_buffer->head = i;
  61   }
  62 }
  63
  64 #if defined(__AVR_ATmega1280__)
  65
  66 SIGNAL(SIG_USART0_RECV)
  67 {
  68   unsigned char c = UDR0;
  69   store_char(c, &rx_buffer);
  70 }
  71
  72 SIGNAL(SIG_USART1_RECV)
  73 {
  74   unsigned char c = UDR1;
  75   store_char(c, &rx_buffer1);
  76 }
  77
  78 SIGNAL(SIG_USART2_RECV)
  79 {
  80   unsigned char c = UDR2;
  81   store_char(c, &rx_buffer2);
  82 }
  83
  84 SIGNAL(SIG_USART3_RECV)
  85 {
  86   unsigned char c = UDR3;
  87   store_char(c, &rx_buffer3);
  88 }
  89
  90 #else
  91
  92 #if defined(__AVR_ATmega8__)
  93 SIGNAL(SIG_UART_RECV)
  94 #else
  95 SIGNAL(USART_RX_vect)
  96 #endif
  97 {
  98 #if defined(__AVR_ATmega8__)
  99   unsigned char c = UDR;
 100 #else
 101   unsigned char c = UDR0;
 102 #endif
 103   store_char(c, &rx_buffer);
 104 }
 105
 106 #endif
 107
 108 // Constructors ////////////////////////////////////////////////////////////////
 109
 110 HardwareSerial::HardwareSerial(ring_buffer *rx_buffer,
 111   volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
 112   volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
 113   volatile uint8_t *udr,
 114   uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udre, uint8_t u2x)
 115 {
 116   _rx_buffer = rx_buffer;
 117   _ubrrh = ubrrh;
 118   _ubrrl = ubrrl;
 119   _ucsra = ucsra;
 120   _ucsrb = ucsrb;
 121   _udr = udr;
 122   _rxen = rxen;
 123   _txen = txen;
 124   _rxcie = rxcie;
 125   _udre = udre;
 126   _u2x = u2x;
 127 }
 128
 129 // Public Methods //////////////////////////////////////////////////////////////
 130
 131 void HardwareSerial::begin(long baud)
 132 {
 133   uint16_t baud_setting;
 134   bool use_u2x;
 135
 136   // U2X mode is needed for baud rates higher than (CPU Hz / 16)
 137   if (baud > F_CPU / 16) {
 138     use_u2x = true;
 139   } else {
 140     // figure out if U2X mode would allow for a better connection
 141
 142     // calculate the percent difference between the baud-rate specified and
 143     // the real baud rate for both U2X and non-U2X mode (0-255 error percent)
 144     uint8_t nonu2x_baud_error = abs((int)(255-((F_CPU/(16*(((F_CPU/8/baud-1)/2)+1))*255)/baud)));
 145     uint8_t u2x_baud_error = abs((int)(255-((F_CPU/(8*(((F_CPU/4/baud-1)/2)+1))*255)/baud)));
 146
 147     // prefer non-U2X mode because it handles clock skew better
 148     use_u2x = (nonu2x_baud_error > u2x_baud_error);
 149   }
 150
 151   if (use_u2x) {
 152     *_ucsra = 1 << _u2x;
 153     baud_setting = (F_CPU / 4 / baud - 1) / 2;
 154   } else {
 155     *_ucsra = 0;
 156     baud_setting = (F_CPU / 8 / baud - 1) / 2;
 157   }
 158
 159   // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
 160   *_ubrrh = baud_setting >> 8;
 161   *_ubrrl = baud_setting;
 162
 163   sbi(*_ucsrb, _rxen);
 164   sbi(*_ucsrb, _txen);
 165   sbi(*_ucsrb, _rxcie);
 166 }
 167
 168 uint8_t HardwareSerial::available(void)
 169 {
 170   return (RX_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % RX_BUFFER_SIZE;
 171 }
 172
 173 int HardwareSerial::read(void)
 174 {
 175   // if the head isn't ahead of the tail, we don't have any characters
 176   if (_rx_buffer->head == _rx_buffer->tail) {
 177     return -1;
 178   } else {
 179     unsigned char c = _rx_buffer->buffer[_rx_buffer->tail];
 180     _rx_buffer->tail = (_rx_buffer->tail + 1) % RX_BUFFER_SIZE;
 181     return c;
 182   }
 183 }
 184
 185 void HardwareSerial::flush()
 186 {
 187   // don't reverse this or there may be problems if the RX interrupt
 188   // occurs after reading the value of rx_buffer_head but before writing
 189   // the value to rx_buffer_tail; the previous value of rx_buffer_head
 190   // may be written to rx_buffer_tail, making it appear as if the buffer
 191   // don't reverse this or there may be problems if the RX interrupt
 192   // occurs after reading the value of rx_buffer_head but before writing
 193   // the value to rx_buffer_tail; the previous value of rx_buffer_head
 194   // may be written to rx_buffer_tail, making it appear as if the buffer
 195   // were full, not empty.
 196   _rx_buffer->head = _rx_buffer->tail;
 197 }
 198
 199 void HardwareSerial::write(uint8_t c)
 200 {
 201   while (!((*_ucsra) & (1 << _udre)))
 202     ;
 203
 204   *_udr = c;
 205 }
 206
 207 // Preinstantiate Objects //////////////////////////////////////////////////////
 208
 209 #if defined(__AVR_ATmega8__)
 210 HardwareSerial Serial(&rx_buffer, &UBRRH, &UBRRL, &UCSRA, &UCSRB, &UDR, RXEN, TXEN, RXCIE, UDRE, U2X);
 211 #else
 212 HardwareSerial Serial(&rx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UCSR0B, &UDR0, RXEN0, TXEN0, RXCIE0, UDRE0, U2X0);
 213 #endif
 214
 215 #if defined(__AVR_ATmega1280__)
 216 HardwareSerial Serial1(&rx_buffer1, &UBRR1H, &UBRR1L, &UCSR1A, &UCSR1B, &UDR1, RXEN1, TXEN1, RXCIE1, UDRE1, U2X1);
 217 HardwareSerial Serial2(&rx_buffer2, &UBRR2H, &UBRR2L, &UCSR2A, &UCSR2B, &UDR2, RXEN2, TXEN2, RXCIE2, UDRE2, U2X2);
 218 HardwareSerial Serial3(&rx_buffer3, &UBRR3H, &UBRR3L, &UCSR3A, &UCSR3B, &UDR3, RXEN3, TXEN3, RXCIE3, UDRE3, U2X3);
 219 #endif