Mirror
/
ardupilot
mirror of https://github.com/ArduPilot/ardupilot
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ardupilot/libraries/FastSerial/FastSerial.h

251 lines
12 KiB
C
Raw Normal View History

"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
// -*- Mode: C++; c-basic-offset: 8; indent-tabs-mode: nil -*-
//
// Interrupt-driven serial transmit/receive library.
//
// Copyright (c) 2010 Michael Smith. All rights reserved.
//
// Receive and baudrate calculations derived from the Arduino
// HardwareSerial driver:
//
// Copyright (c) 2006 Nicholas Zambetti. All right reserved.
//
// Transmit algorithm inspired by work:
//
// Code Jose Julio and Jordi Munoz. DIYDrones.com
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later
// version.
//
// This library 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 Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General
// Public License along with this library; if not, write to the
// Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
// Boston, MA 02110-1301 USA
//
//
// Note that this library does not pre-declare drivers for serial
// ports; the user must explicitly create drivers for the ports they
// wish to use. This is less friendly than the stock Arduino driver,
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
// but it saves ~200 bytes for every unused port.
"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
//
#ifndef FastSerial_h
#define FastSerial_h
Change the way that FastSerial ports are created, so that we can avoid creating port drivers for ports that aren't used. This lets us save the RAM (~200 bytes per port) that would otherwise have been used for buffers. It also frees up the port's interrupt vectors so that on Mega we can use the ports for other things (e.g. SPI Master mode). Better to fix this now than later when we have more consumers. git-svn-id: https://arducopter.googlecode.com/svn/trunk@355 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-30 01:01:15 -03:00
// disable the stock Arduino serial driver
Update to take advantage of the new Stream class in Arduino 0019. git-svn-id: https://arducopter.googlecode.com/svn/trunk@387 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-05 16:43:08 -03:00
#ifdef HardwareSerial_h
# error Must include FastSerial.h before the Arduino serial driver is defined.
#endif
Change the way that FastSerial ports are created, so that we can avoid creating port drivers for ports that aren't used. This lets us save the RAM (~200 bytes per port) that would otherwise have been used for buffers. It also frees up the port's interrupt vectors so that on Mega we can use the ports for other things (e.g. SPI Master mode). Better to fix this now than later when we have more consumers. git-svn-id: https://arducopter.googlecode.com/svn/trunk@355 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-30 01:01:15 -03:00
#define HardwareSerial_h
"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
#include <inttypes.h>
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
#include <stdio.h>
Dynamically allocate serial buffers at ::begin time. Allow buffer sizes to be dynamically set. This provides an opportunity for saving memory in the case of ports that do little or no work (e.g. the console) as well as increasing buffering for ports that receive large amounts of data in a short time (e.g. high-bitrate NMEA). git-svn-id: https://arducopter.googlecode.com/svn/trunk@425 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-07 02:41:35 -03:00
#include <stdlib.h>
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
#include <avr/interrupt.h>
"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
Factor the Stream-related enhancements out from FastSerial proper, so that we could use them on other Stream subclasses if that seemed worthwhile. Add print_P and println_P implementations to give folks wedded to the vanilla Stream methods a way to print PROGMEM strings. git-svn-id: https://arducopter.googlecode.com/svn/trunk@715 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-10-23 02:59:40 -03:00
#include "BetterStream.h"
Change the way that FastSerial ports are created, so that we can avoid creating port drivers for ports that aren't used. This lets us save the RAM (~200 bytes per port) that would otherwise have been used for buffers. It also frees up the port's interrupt vectors so that on Mega we can use the ports for other things (e.g. SPI Master mode). Better to fix this now than later when we have more consumers. git-svn-id: https://arducopter.googlecode.com/svn/trunk@355 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-30 01:01:15 -03:00
//
// Because Arduino libraries aren't really libraries, but we want to
// only define interrupt handlers for serial ports that are actually
// used, we have to force our users to define them using a macro.
//
// Due to the way interrupt vectors are specified, we have to have
// a separate macro for every port. Ugh.
//
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
// The macros are:
//
// FastSerialPort0(<port name>) creates <port name> referencing serial port 0
// FastSerialPort1(<port name>) creates <port name> referencing serial port 1
// FastSerialPort2(<port name>) creates <port name> referencing serial port 2
// FastSerialPort3(<port name>) creates <port name> referencing serial port 3
//
//
// Forward declarations for clients that want to assume that the
// default Serial* objects exist.
//
// Note that the application is responsible for ensuring that these
// actually get defined, otherwise Arduino will suck in the
// HardwareSerial library and linking will fail.
//
extern class FastSerial Serial;
extern class FastSerial Serial1;
extern class FastSerial Serial2;
extern class FastSerial Serial3;
Factor the Stream-related enhancements out from FastSerial proper, so that we could use them on other Stream subclasses if that seemed worthwhile. Add print_P and println_P implementations to give folks wedded to the vanilla Stream methods a way to print PROGMEM strings. git-svn-id: https://arducopter.googlecode.com/svn/trunk@715 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-10-23 02:59:40 -03:00
class FastSerial : public BetterStream {
"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
public:
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
FastSerial(const uint8_t portNumber,
volatile uint8_t *ubrrh,
volatile uint8_t *ubrrl,
volatile uint8_t *ucsra,
volatile uint8_t *ucsrb,
volatile uint8_t *udr,
const uint8_t u2x,
const uint8_t portEnableBits,
const uint8_t portTxBits);
"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
// Serial API
Factor the Stream-related enhancements out from FastSerial proper, so that we could use them on other Stream subclasses if that seemed worthwhile. Add print_P and println_P implementations to give folks wedded to the vanilla Stream methods a way to print PROGMEM strings. git-svn-id: https://arducopter.googlecode.com/svn/trunk@715 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-10-23 02:59:40 -03:00
virtual void begin(long baud);
virtual void begin(long baud, unsigned int rxSpace, unsigned int txSpace);
virtual void end(void);
virtual int available(void);
virtual int read(void);
virtual void flush(void);
virtual void write(uint8_t c);
using BetterStream::write;
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
// public so the interrupt handlers can see it
struct Buffer {
volatile uint16_t head, tail;
uint16_t mask;
uint8_t *bytes;
};
"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
private:
// register accessors
volatile uint8_t *_ubrrh;
volatile uint8_t *_ubrrl;
volatile uint8_t *_ucsra;
volatile uint8_t *_ucsrb;
volatile uint8_t *_udr;
// register magic numbers
uint8_t _portEnableBits; // rx, tx and rx interrupt enables
uint8_t _portTxBits; // tx data and completion interrupt enables
uint8_t _u2x;
// ring buffers
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
Buffer *_rxBuffer;
Buffer *_txBuffer;
Dynamically allocate serial buffers at ::begin time. Allow buffer sizes to be dynamically set. This provides an opportunity for saving memory in the case of ports that do little or no work (e.g. the console) as well as increasing buffering for ports that receive large amounts of data in a short time (e.g. high-bitrate NMEA). git-svn-id: https://arducopter.googlecode.com/svn/trunk@425 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-07 02:41:35 -03:00
bool _open;
bool _allocBuffer(Buffer *buffer, unsigned int size);
void _freeBuffer(Buffer *buffer);
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
};
Add 'extern' definitions to legitimise clients that want to assume that Serial* always exists. git-svn-id: https://arducopter.googlecode.com/svn/trunk@321 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-26 23:29:14 -03:00
Change the way that FastSerial ports are created, so that we can avoid creating port drivers for ports that aren't used. This lets us save the RAM (~200 bytes per port) that would otherwise have been used for buffers. It also frees up the port's interrupt vectors so that on Mega we can use the ports for other things (e.g. SPI Master mode). Better to fix this now than later when we have more consumers. git-svn-id: https://arducopter.googlecode.com/svn/trunk@355 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-30 01:01:15 -03:00
// Used by the per-port interrupt vectors
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
extern FastSerial::Buffer __FastSerial__rxBuffer[];
extern FastSerial::Buffer __FastSerial__txBuffer[];
Change the way that FastSerial ports are created, so that we can avoid creating port drivers for ports that aren't used. This lets us save the RAM (~200 bytes per port) that would otherwise have been used for buffers. It also frees up the port's interrupt vectors so that on Mega we can use the ports for other things (e.g. SPI Master mode). Better to fix this now than later when we have more consumers. git-svn-id: https://arducopter.googlecode.com/svn/trunk@355 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-30 01:01:15 -03:00
// Generic Rx/Tx vectors for a serial port - needs to know magic numbers
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
#define FastSerialHandler(_PORT, _RXVECTOR, _TXVECTOR, _UDR, _UCSRB, _TXBITS) \
ISR(_RXVECTOR, ISR_BLOCK) \
{ \
uint8_t c; \
int16_t i; \
\
/* read the byte as quickly as possible */ \
c = _UDR; \
/* work out where the head will go next */ \
i = (__FastSerial__rxBuffer[_PORT].head + 1) & __FastSerial__rxBuffer[_PORT].mask; \
/* decide whether we have space for another byte */ \
if (i != __FastSerial__rxBuffer[_PORT].tail) { \
/* we do, move the head */ \
__FastSerial__rxBuffer[_PORT].bytes[__FastSerial__rxBuffer[_PORT].head] = c; \
__FastSerial__rxBuffer[_PORT].head = i; \
} \
} \
ISR(_TXVECTOR, ISR_BLOCK) \
{ \
Stop trying to be so clever in the tx interrupt handler. We may race with the code stuffing bytes into the ring such that we consume the last byte and empty the ring before they set the UDRE interrupt. If that happens since we weren't checking the ring for emptiness we would loop and spit out the whole ring again. It's cheaper in terms of interrupt latency to just check the ring at interrupt time than it is to futz with ATOMIC_BLOCKs in the ::write code. git-svn-id: https://arducopter.googlecode.com/svn/trunk@535 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-22 03:56:27 -03:00
/* if there is another character to send */ \
if (__FastSerial__txBuffer[_PORT].tail != __FastSerial__txBuffer[_PORT].head) { \
_UDR = __FastSerial__txBuffer[_PORT].bytes[__FastSerial__txBuffer[_PORT].tail]; \
/* increment the tail */ \
__FastSerial__txBuffer[_PORT].tail = \
(__FastSerial__txBuffer[_PORT].tail + 1) & __FastSerial__txBuffer[_PORT].mask; \
} else { \
/* there are no more bytes to send, disable the interrupt */ \
if (__FastSerial__txBuffer[_PORT].head == __FastSerial__txBuffer[_PORT].tail) \
_UCSRB &= ~_TXBITS; \
} \
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
} \
Change the way that FastSerial ports are created, so that we can avoid creating port drivers for ports that aren't used. This lets us save the RAM (~200 bytes per port) that would otherwise have been used for buffers. It also frees up the port's interrupt vectors so that on Mega we can use the ports for other things (e.g. SPI Master mode). Better to fix this now than later when we have more consumers. git-svn-id: https://arducopter.googlecode.com/svn/trunk@355 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-30 01:01:15 -03:00
struct hack
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
// Macros defining serial ports
Per Jose, fix the interrupt vectors to work for non-1280-based Arduino. Make Serial0 also stdin and stderr. git-svn-id: https://arducopter.googlecode.com/svn/trunk@534 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-22 00:00:10 -03:00
#if defined(__AVR_ATmega1280__)
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
#define FastSerialPort0(_portName) \
FastSerial _portName(0, \
&UBRR0H, \
&UBRR0L, \
&UCSR0A, \
&UCSR0B, \
&UDR0, \
U2X0, \
(_BV(RXEN0) | _BV(TXEN0) | _BV(RXCIE0)), \
(_BV(UDRIE0))); \
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
FastSerialHandler(0, SIG_USART0_RECV, SIG_USART0_DATA, UDR0, UCSR0B, _BV(UDRIE0))
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
#define FastSerialPort1(_portName) \
FastSerial _portName(1, \
&UBRR1H, \
&UBRR1L, \
&UCSR1A, \
&UCSR1B, \
&UDR1, \
U2X1, \
(_BV(RXEN1) | _BV(TXEN1) | _BV(RXCIE1)), \
(_BV(UDRIE1))); \
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
FastSerialHandler(1, SIG_USART1_RECV, SIG_USART1_DATA, UDR1, UCSR1B, _BV(UDRIE1))
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
#define FastSerialPort2(_portName) \
FastSerial _portName(2, \
&UBRR2H, \
&UBRR2L, \
&UCSR2A, \
&UCSR2B, \
&UDR2, \
U2X2, \
(_BV(RXEN2) | _BV(TXEN2) | _BV(RXCIE2)), \
(_BV(UDRIE2))); \
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
FastSerialHandler(2, SIG_USART2_RECV, SIG_USART2_DATA, UDR2, UCSR2B, _BV(UDRIE2))
Change the way the port declaration macros work. This saves ~300 bytes by shrinking the constructor. I don't quite understand why g++ is emitting two identical copies of the ctor, but it wastes a bunch of space. 8( Integrate FastSerial with the C library's standard I/O. Add new ::printf and ::printf_P methods that do the obvious thing, and a ::getfd method so that a caller can use the other stdio functions with the port if that's interesting. git-svn-id: https://arducopter.googlecode.com/svn/trunk@361 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-31 03:22:54 -03:00
#define FastSerialPort3(_portName) \
FastSerial _portName(3, \
&UBRR3H, \
&UBRR3L, \
&UCSR3A, \
&UCSR3B, \
&UDR3, \
U2X3, \
(_BV(RXEN3) | _BV(TXEN3) | _BV(RXCIE3)), \
(_BV(UDRIE3))); \
Remove the method call from the interrupt handlers. This brings the rx and tx interrupt paths down to < 60 instructions worst case, or ~4us. At 115200 we expect ~100us between interrupts, or around 5% CPU overhead. 4us latency is probably acceptable for servo signal jitter too if we decide to consider using the Arduino Servo library. git-svn-id: https://arducopter.googlecode.com/svn/trunk@513 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-13 14:44:59 -03:00
FastSerialHandler(3, SIG_USART3_RECV, SIG_USART3_DATA, UDR3, UCSR3B, _BV(UDRIE3))
Per Jose, fix the interrupt vectors to work for non-1280-based Arduino. Make Serial0 also stdin and stderr. git-svn-id: https://arducopter.googlecode.com/svn/trunk@534 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-09-22 00:00:10 -03:00
#else
#if defined(__AVR_ATmega8__)
#define FastSerialPort0(_portName) \
FastSerial _portName(0, \
&UBRR0H, \
&UBRR0L, \
&UCSR0A, \
&UCSR0B, \
&UDR0, \
U2X0, \
(_BV(RXEN0) | _BV(TXEN0) | _BV(RXCIE0)), \
(_BV(UDRIE0))); \
FastSerialHandler(0, SIG_UART_RECV, SIG_UART_DATA, UDR0, UCSR0B, _BV(UDRIE0))
#else
// note no SIG_USART_* defines for the 168, 328, etc.
#define FastSerialPort0(_portName) \
FastSerial _portName(0, \
&UBRR0H, \
&UBRR0L, \
&UCSR0A, \
&UCSR0B, \
&UDR0, \
U2X0, \
(_BV(RXEN0) | _BV(TXEN0) | _BV(RXCIE0)), \
(_BV(UDRIE0))); \
FastSerialHandler(0, USART_RX_vect, USART_UDRE_vect, UDR0, UCSR0B, _BV(UDRIE0))
#endif
Change the way that FastSerial ports are created, so that we can avoid creating port drivers for ports that aren't used. This lets us save the RAM (~200 bytes per port) that would otherwise have been used for buffers. It also frees up the port's interrupt vectors so that on Mega we can use the ports for other things (e.g. SPI Master mode). Better to fix this now than later when we have more consumers. git-svn-id: https://arducopter.googlecode.com/svn/trunk@355 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-30 01:01:15 -03:00
#endif
"Fast" serial driver that fully overrides the Arduino-provided HardwareSerial/Serial* driver. The receive side is basically a copy of the HardwareSerial driver, whilst the transmit side uses the same algorithm as the APM_FastSerial driver. See the example sketch for usage details. git-svn-id: https://arducopter.googlecode.com/svn/trunk@276 f9c3cf11-9bcb-44bc-f272-b75c42450872
2010-08-23 03:25:03 -03:00
#endif // FastSerial_h