ahoneybun/qmk_firmware
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename Drivers/AT90USBXXX to Drivers/Peripheral.

Browse source
This commit is contained in:
Dean Camera 2009-04-17 00:12:31 +00:00
parent 710d48a48a
commit 5712b8dff6
7 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

87
LUFA/Drivers/Peripheral/ADC.h Normal file
View file

@ -0,0 +1,87 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2009.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* This file is the master dispatch header file for the device-specific ADC driver, for AVRs containing an ADC.
*
* User code should include this file, which will in turn include the correct ADC driver header file for the
* currently selected AVR model.
*/
/** \ingroup Group_SubsystemDrivers
* @defgroup Group_ADC ADC Driver - LUFA/Drivers/Peripheral/ADC.h
*/
#ifndef __ADC_H__
#define __ADC_H__
/* Macros: */
#if !defined(__DOXYGEN__)
#define INCLUDE_FROM_ADC_H
#define INCLUDE_FROM_CHIP_DRIVER
#endif
/* Includes: */
#if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || \
defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB647__) || \
defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || \
defined(__AVR_ATmega32U6__))
#include "AT90USBXXX67/ADC.h"
#else
#error "ADC is not available for the currently selected AVR model."
#endif
/* Public Interface - May be used in end-application: */
/* Inline Functions: */
/** Starts the reading of the given channel, but does not wait until the conversion has completed.
* Once executed, the conversion status can be determined via the ADC_IsReadingComplete() macro and
* the result read via the ADC_GetResult() macro.
*
* \param MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
*/
static inline void ADC_StartReading(const uint8_t MUXMask);
/** Performs a complete single reading from channel, including a polling spinloop to wait for the
* conversion to complete, and the returning of the converted value.
*
* \param MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
*/
static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask) ATTR_WARN_UNUSED_RESULT;
/** Configures the given ADC channel, ready for ADC conversions. This function sets the
* associated port pin as an input and disables the digital portion of the I/O to reduce
* power consumption.
*
* \param Channel ADC channel number to set up for conversions
*/
static inline void ADC_SetupChannel(const uint8_t Channel);
#endif

185
LUFA/Drivers/Peripheral/AT90USBXXX67/ADC.h Normal file
View file

@ -0,0 +1,185 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2009.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* ADC driver for the AT90USB1287, AT90USB1286, AT90USB647, AT90USB646, ATMEGA16U4 and ATMEGA32U4 AVRs.
*
* \note This file should not be included directly. It is automatically included as needed by the ADC driver
* dispatch header located in LUFA/Drivers/Peripheral/ADC.h.
*/
/** \ingroup Group_ADC
* @defgroup Group_ADC_AT90USBXXX67 AT90USBXXX6 and AT90USBXXX7 Models
*
* @{
*/
#ifndef __ADC_AT90USBXXX67_H__
#define __ADC_AT90USBXXX67_H__
/* Includes: */
#include "../../../Common/Common.h"
#include <avr/io.h>
#include <stdbool.h>
/* Enable C linkage for C++ Compilers: */
#if defined(__cplusplus)
extern "C" {
#endif
/* Preprocessor Checks: */
#if !defined(INCLUDE_FROM_ADC_H)
#error Do not include this file directly. Include LUFA/Drivers/Peripheral/ADC.h instead.
#endif
/* Public Interface - May be used in end-application: */
/* Macros: */
/** Initializes the ADC, ready for conversions. This must be called before any other ADC operations.
* The "mode" parameter should be a mask comprised of a conversion mode (free running or single) and
* prescaler masks.
*/
#define ADC_Init(mode) MACROS{ ADCSRA = ((1 << ADEN) | mode); }MACROE
/** Turns off the ADC. If this is called, any further ADC operations will require a call to the
* ADC_Init() macro before the ADC can be used again.
*/
#define ADC_Off() MACROS{ ADCSRA = 0; }MACROE
/** Indicates if the ADC is enabled. This macro will return boolean true if the ADC subsystem is
* currently enabled, or false otherwise.
*/
#define ADC_GetStatus() ((ADCSRA & (1 << ADEN)) ? true : false)
/** Indicates if the current ADC conversion is completed, or still in progress. This returns boolean
* false if the reading is still taking place, or true if the conversion is complete and ready to be
* read out with ADC_GetResult().
*/
#define ADC_IsReadingComplete() (!(ADCSRA & (1 << ADSC)))
/** Returns the result of the last conversion, as a 16-bit wide integer. */
#define ADC_GetResult() ADC
/** Reference mask, for using the voltage present at the AVR's AREF pin for the ADC reference. */
#define ADC_REFERENCE_AREF 0
/** Reference mask, for using the voltage present at the AVR's AVCC pin for the ADC reference. */
#define ADC_REFERENCE_AVCC (1 << REFS0)
/** Reference mask, for using the internally generated 2.56V reference voltage as the ADC reference. */
#define ADC_REFERENCE_INT2560MV ((1 << REFS1)| (1 << REFS0))
/** Left-adjusts the 10-bit ADC result, so that the upper 8 bits of the value returned by the
* ADC_GetResult() macro contain the 8 most significant bits of the result. */
#define ADC_LEFT_ADJUSTED (1 << ADLAR)
/** Right-adjusts the 10-bit ADC result, so that the lower 8 bits of the value returned by the
* ADC_GetResult() macro contain the 8 least significant bits of the result. */
#define ADC_RIGHT_ADJUSTED (0 << ADLAR)
/** Sets the ADC mode to free running, so that conversions take place continuously as fast as the ADC
* is capable of at the given input clock speed. */
#define ADC_FREE_RUNNING (1 << ADATE)
/** Sets the ADC mode to single conversion, so that only a single conversion will take place before
* the ADC returns to idle. */
#define ADC_SINGLE_CONVERSION (0 << ADATE)
/** Sets the ADC input clock to prescale by a factor of 2 the AVR's system clock. */
#define ADC_PRESCALE_2 (1 << ADPS0)
/** Sets the ADC input clock to prescale by a factor of 4 the AVR's system clock. */
#define ADC_PRESCALE_4 (1 << ADPS1)
/** Sets the ADC input clock to prescale by a factor of 8 the AVR's system clock. */
#define ADC_PRESCALE_8 ((1 << ADPS0) | (1 << ADPS1))
/** Sets the ADC input clock to prescale by a factor of 16 the AVR's system clock. */
#define ADC_PRESCALE_16 (1 << ADPS2)
/** Sets the ADC input clock to prescale by a factor of 32 the AVR's system clock. */
#define ADC_PRESCALE_32 ((1 << ADPS2) | (1 << ADPS0))
/** Sets the ADC input clock to prescale by a factor of 64 the AVR's system clock. */
#define ADC_PRESCALE_64 ((1 << ADPS2) | (1 << ADPS1))
/** Sets the ADC input clock to prescale by a factor of 128 the AVR's system clock. */
#define ADC_PRESCALE_128 ((1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0))
/* Inline Functions: */
/** Configures the given ADC channel, ready for ADC conversions. This function sets the
* associated port pin as an input and disables the digital portion of the I/O to reduce
* power consumption.
*
* \param Channel ADC channel number to set up for conversions
*/
static inline void ADC_SetupChannel(const uint8_t Channel)
{
DDRF &= ~(1 << Channel);
DIDR0 |= (1 << Channel);
}
/** Starts the reading of the given channel, but does not wait until the conversion has completed.
* Once executed, the conversion status can be determined via the ADC_IsReadingComplete() macro and
* the result read via the ADC_GetResult() macro.
*
* \param MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
*/
static inline void ADC_StartReading(const uint8_t MUXMask)
{
ADMUX = MUXMask;
ADCSRA |= (1 << ADSC);
}
/** Performs a complete single reading from channel, including a polling spinloop to wait for the
* conversion to complete, and the returning of the converted value.
*
* \param MUXMask Mask comprising of an ADC channel number, reference mask and adjustment mask
*/
static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask) ATTR_WARN_UNUSED_RESULT;
static inline uint16_t ADC_GetChannelReading(const uint8_t MUXMask)
{
ADC_StartReading(MUXMask);
while (!(ADC_IsReadingComplete()));
return ADC_GetResult();
}
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)
}
#endif
#endif
/** @} */

149
LUFA/Drivers/Peripheral/SPI.h Normal file
View file

@ -0,0 +1,149 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2009.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Hardware SPI subsystem driver for the supported USB AVRs models.
*/
/** \ingroup Group_SubsystemDrivers
* @defgroup Group_SPI SPI Driver - LUFA/Drivers/Peripheral/SPI.h
*
* Functions, macros, variables, enums and types related to the setup of a the SPI port.
*
* @{
*/
#ifndef __SPI_H__
#define __SPI_H__
/* Includes: */
#include <stdbool.h>
/* Enable C linkage for C++ Compilers: */
#if defined(__cplusplus)
extern "C" {
#endif
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* Macros: */
#define SPI_USE_DOUBLESPEED (1 << 7)
#endif
/* Public Interface - May be used in end-application: */
/* Macros: */
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 2. */
#define SPI_SPEED_FCPU_DIV_2 SPI_USE_DOUBLESPEED
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 4. */
#define SPI_SPEED_FCPU_DIV_4 0
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 8. */
#define SPI_SPEED_FCPU_DIV_8 (SPI_USE_DOUBLESPEED | (1 << SPR0))
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 16. */
#define SPI_SPEED_FCPU_DIV_16 (1 << SPR0)
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 32. */
#define SPI_SPEED_FCPU_DIV_32 (SPI_USE_DOUBLESPEED | (1 << SPR1))
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 64. */
#define SPI_SPEED_FCPU_DIV_64 (SPI_USE_DOUBLESPEED | (1 << SPR1) | (1 << SPR0))
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 128. */
#define SPI_SPEED_FCPU_DIV_128 ((1 << SPR1) | (1 << SPR0))
/* Inline Functions: */
/** Initializes the SPI subsystem, ready for transfers. Must be called before calling any other
* SPI routines.
*
* \param PrescalerMask Prescaler mask to set the SPI clock speed
* \param Master If true, sets the SPI system to use master mode, slave if false
*/
static inline void SPI_Init(const uint8_t PrescalerMask, const bool Master)
{
DDRB |= ((1 << 1) | (1 << 2));
PORTB |= ((1 << 0) | (1 << 3));
SPCR = ((1 << SPE) | (Master << MSTR) | (1 << CPOL) | (1 << CPHA) |
(PrescalerMask & ~SPI_USE_DOUBLESPEED));
if (PrescalerMask & SPI_USE_DOUBLESPEED)
SPSR = (1 << SPI2X);
}
/** Sends and receives a byte through the SPI interface, blocking until the transfer is complete.
*
* \param Byte Byte to send through the SPI interface
*
* \return Response byte from the attached SPI device
*/
static inline uint8_t SPI_TransferByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline uint8_t SPI_TransferByte(const uint8_t Byte)
{
SPDR = Byte;
while (!(SPSR & (1 << SPIF)));
return SPDR;
}
/** Sends a byte through the SPI interface, blocking until the transfer is complete. The response
* byte sent to from the attached SPI device is ignored.
*
* \param Byte Byte to send through the SPI interface
*/
static inline void SPI_SendByte(const uint8_t Byte) ATTR_ALWAYS_INLINE;
static inline void SPI_SendByte(const uint8_t Byte)
{
SPDR = Byte;
while (!(SPSR & (1 << SPIF)));
}
/** Sends a dummy byte through the SPI interface, blocking until the transfer is complete. The response
* byte from the attached SPI device is returned.
*
* \return The response byte from the attached SPI device
*/
static inline uint8_t SPI_ReceiveByte(void) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline uint8_t SPI_ReceiveByte(void)
{
SPDR = 0x00;
while (!(SPSR & (1 << SPIF)));
return SPDR;
}
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)
}
#endif
#endif
/** @} */

65
LUFA/Drivers/Peripheral/Serial.c Normal file
View file

@ -0,0 +1,65 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2009.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
#include "Serial.h"
void Serial_Init(const uint32_t BaudRate, const bool DoubleSpeed)
{
UCSR1A = ((DoubleSpeed) ? (1 << U2X1) : 0);
UCSR1B = ((1 << RXEN1) | (1 << TXEN1));
UCSR1C = ((1 << UCSZ11) | (1 << UCSZ10));
DDRD |= (1 << 3);
PORTD |= (1 << 2);
UBRR1 = SERIAL_UBBRVAL(BaudRate);
}
void Serial_TxString_P(const char *FlashStringPtr)
{
uint8_t CurrByte;
while ((CurrByte = pgm_read_byte(FlashStringPtr)) != 0x00)
{
Serial_TxByte(CurrByte);
FlashStringPtr++;
}
}
void Serial_TxString(const char *StringPtr)
{
uint8_t CurrByte;
while ((CurrByte = *StringPtr) != 0x00)
{
Serial_TxByte(CurrByte);
StringPtr++;
}
}

125
LUFA/Drivers/Peripheral/Serial.h Normal file
View file

@ -0,0 +1,125 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2009.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Driver for the USART subsystem on supported USB AVRs.
*/
/** \ingroup Group_SubsystemDrivers
* @defgroup Group_Serial Serial USART Driver - LUFA/Drivers/Peripheral/Serial.h
*
* Functions, macros, variables, enums and types related to the setup of the USART for serial communications.
*
* @{
*/
#ifndef __SERIAL_H__
#define __SERIAL_H__
/* Includes: */
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <stdbool.h>
#include "../../Common/Common.h"
#include "../Misc/TerminalCodes.h"
/* Enable C linkage for C++ Compilers: */
#if defined(__cplusplus)
extern "C" {
#endif
/* Public Interface - May be used in end-application: */
/* Macros: */
/** Indicates whether a character has been received through the USART - boolean false if no character
* has been received, or non-zero if a character is waiting to be read from the reception buffer.
*/
#define Serial_IsCharReceived() ((UCSR1A & (1 << RXC1)) ? true : false)
/** Macro for calculating the baud value from a given baud rate when the U2X (double speed) bit is
* not set.
*/
#define SERIAL_UBBRVAL(baud) (((F_CPU / 16) / baud) - 1)
/** Macro for calculating the baud value from a given baud rate when the U2X (double speed) bit is
* set.
*/
#define SERIAL_2X_UBBRVAL(baud) (((F_CPU / 8) / baud) - 1)
/* Function Prototypes: */
/** Initializes the USART, ready for serial data transmission and reception.
*
* \param BaudRate Baud rate to configure the USART to
* \param DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate
*/
void Serial_Init(const uint32_t BaudRate, const bool DoubleSpeed);
/** Transmits a given string located in program space (FLASH) through the USART.
*
* \param FlashStringPtr Pointer to a string located in program space
*/
void Serial_TxString_P(const char *FlashStringPtr) ATTR_NON_NULL_PTR_ARG(1);
/** Transmits a given string located in SRAM memory through the USART.
*
* \param StringPtr Pointer to a string located in SRAM space
*/
void Serial_TxString(const char *StringPtr) ATTR_NON_NULL_PTR_ARG(1);
/* Inline Functions: */
/** Transmits a given byte through the USART.
*
* \param DataByte Byte to transmit through the USART
*/
static inline void Serial_TxByte(const char DataByte)
{
while (!(UCSR1A & (1 << UDRE1)));
UDR1 = DataByte;
}
/** Receives a byte from the USART.
*
* \return Byte received from the USART
*/
static inline char Serial_RxByte(void)
{
while (!(UCSR1A & (1 << RXC1)));
return UDR1;
}
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)
}
#endif
#endif
/** @} */

45
LUFA/Drivers/Peripheral/Serial_Stream.c Normal file
View file

@ -0,0 +1,45 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2009.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
#include "Serial_Stream.h"
FILE USARTStream = FDEV_SETUP_STREAM(SerialStream_TxByte, SerialStream_RxByte, _FDEV_SETUP_RW);
int SerialStream_TxByte(char DataByte, FILE *Stream)
{
Serial_TxByte(DataByte);
return 0;
}
int SerialStream_RxByte(FILE *Stream)
{
return Serial_RxByte();
}

93
LUFA/Drivers/Peripheral/Serial_Stream.h Normal file
View file

@ -0,0 +1,93 @@
/*
LUFA Library
Copyright (C) Dean Camera, 2009.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2009 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, and distribute this software
and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Serial stream driver for the USART subsystem on supported USB AVRs. This makes use of the functions in the
* regular USART driver, but allows the avr-libc standard stream functions (printf, puts, etc.) to work with the
* USART.
**/
/** \ingroup Group_SubsystemDrivers
* @defgroup Group_SerialStream Serial Stream Driver - LUFA/Drivers/Peripheral/Serial_Stream.h
*
* Functions, macros, variables, enums and types related to the setup of a serial stream, so that standard printf and other
* C stream functions can be used on the serial port.
*
* @{
*/
#ifndef __SERIAL_STREAM_H__
#define __SERIAL_STREAM_H__
/* Includes: */
#include <avr/io.h>
#include <stdio.h>
#include "Serial.h"
/* Enable C linkage for C++ Compilers: */
#if defined(__cplusplus)
extern "C" {
#endif
/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
/* External Variables: */
extern FILE USARTStream;
/* Function Prototypes: */
int SerialStream_TxByte(char DataByte, FILE *Stream) ATTR_NON_NULL_PTR_ARG(2);
int SerialStream_RxByte(FILE *Stream) ATTR_NON_NULL_PTR_ARG(1);
#endif
/* Public Interface - May be used in end-application: */
/* Inline Functions: */
/** Initializes the serial stream (and regular USART driver) so that both the stream and regular
* USART driver functions can be used. Must be called before any stream or regular USART functions.
*
* \param BaudRate Baud rate to configure the USART to
* \param DoubleSpeed Enables double speed mode when set, halving the sample time to double the baud rate
*/
static inline void SerialStream_Init(const uint32_t BaudRate, const bool DoubleSpeed)
{
Serial_Init(BaudRate, DoubleSpeed);
stdout = &USARTStream;
}
/* Disable C linkage for C++ Compilers: */
#if defined(__cplusplus)
}
#endif
#endif
/** @} */