Detailed Description

PrintStream library

Namespaces
namespace	detail

namespace	ExtIO
	A namespace with alternatives to the standard Arduino IO functions that can be used with extended IO pin numbers.

Classes
class	AnalogMultiplex
	A class for reading multiplexed analog inputs. More...

struct	Array
	An array wrapper for easy copying, comparing, and iterating. More...

class	ArraySlice
	Class for a view on a slice of an array. More...

class	BitArray
	A class for arrays of bits. More...

class	Button
	A class for reading and debouncing buttons and switches. More...

class	ButtonMatrix
	A class that reads the states of a button matrix. More...

class	DotBarDisplayLEDs
	A class for LED bars. More...

struct	EulerAngles
	Struct for Euler angles of floating point numbers. More...

class	ExtendedIOElement
	An abstract base class for Extended Input/Output elements. More...

class	FilteredAnalog
	A class that reads and filters an analog input. More...

class	Frequency
	Type-safe class for frequency values. More...

struct	function_traits

struct	function_traits< Return(Args...)>

class	GenericFilteredAnalog
	FilteredAnalog base class with generic MappingFunction. More...

struct	HexDump

class	IncrementButton
	A class for buttons that increment some counter or setting. More...

class	IncrementDecrementButtons
	A class for buttons that increment and decrement some counter or setting. More...

class	LEDs
	A class for collections of LEDs that can display ranges. More...

class	MAX7219
	A class for LED outputs using the MAX7219 LED display driver. More...

class	MAX7219_Base
	A base class for classes that control MAX7219 LED drivers. More...

class	MAX7219SevenSegmentDisplay
	A class for 8-digit 7-segment displays with a MAX7219 driver. More...

struct	MaximumFilteredAnalogIncRes
	Helper to determine how many of the remaining bits of the filter data types can be used to achieve higher precision. More...

class	MCP23017
	Class for MCP23017 I²C I/O expanders. More...

class	MCP23017Encoders
	Class for reading 8 rotary encoders using a MCP23017 I²C port expander. More...

struct	NormalUpdatable

struct	Quaternion
	Type for quaternions of floating point numbers. More...

struct	Setbase

struct	Setbytesep

struct	Setprecision

class	ShiftRegisterOut
	A class for serial-in/parallel-out shift registers, like the 74HC595. More...

class	ShiftRegisterOutBase
	A class for serial-in/parallel-out shift registers, like the 74HC595. More...

struct	ShiftRegisterOutRGB
	A struct for setting the RGB mode for RGB shift registers. More...

class	SPIShiftRegisterOut
	A class for serial-in/parallel-out shift registers, like the 74HC595 that are connected to the SPI bus. More...

class	StaticSizeExtendedIOElement
	A class for ExtendedIOElements with a fixed size. More...

class	Timer
	A class for easily managing timed events. More...

class	Updatable
	A super class for object that have to be updated regularly. More...

class	UpdatableCRTP
	A super class for object that have to be updated regularly. More...

struct	Vec2f
	Type for 2D vectors of floating point numbers. More...

struct	Vec3f
	Type for 3D vectors of floating point numbers. More...

Typedefs
template<class T , size_t NumRows, size_t NumCols>
using	Array2D = Array< Array< T, NumCols >, NumRows >
	An easy alias for two-dimensional Arrays.

using	CD74HC4067 = AnalogMultiplex< 4 >
	An alias for AnalogMultiplex<4> to use with CD74HC4067 analog multiplexers.

using	CD74HC4051 = AnalogMultiplex< 3 >
	An alias for AnalogMultiplex<3> to use with CD74HC4051 analog multiplexers.

using	analog_t = uint16_t
	The type returned from analogRead and similar functions.

using	pin_t = uint16_t
	The type for Arduino pins (and ExtendedIOElement pins).

template<size_t N>
using	PinList = Array< pin_t, N >
	An easy alias for arrays of pins.

typedef Print &	manipulator(Print &)

using	ANALOG_FILTER_TYPE = uint16_t
	The unsigned integer type to use for analog inputs during filtering. More...

using	timefunction = unsigned long(*)()
	A function type that returns a time value.

Enumerations
enum	MCP23017RegAddr { IODIRA = 0x00 , IODIRB = 0x01 , IPOLA = 0x02 , IPOLB = 0x03 , GPINTENA = 0x04 , GPINTENB = 0x05 , DEFVALA = 0x06 , DEFVALB = 0x07 , INTCONA = 0x08 , INTCONB = 0x09 , IOCON = 0x0A , GPPUA = 0x0C , GPPUB = 0x0D , INTFA = 0x0E , INTFB = 0x0F , INTCAPA = 0x10 , INTCAPB = 0x11 , GPIOA = 0x12 , GPIOB = 0x13 , OLATA = 0x14 , OLATB = 0x15 }

enum class	DotBarMode : bool { Bar = false , Dot = true }
	An enumeration type to set an LED display to either bar or dot mode. More...

enum	: char { LOWERCASE = 0x7F , UPPERCASE = 0x5F }

Functions
template<class T >
constexpr T	abs_diff (const T &a, const T &b)

template<class T , size_t N, class G >
Array< T, N >	generateArray (G generator)
	Generate an array using the given generator. More...

template<size_t N, class G >
auto	generateArray (G generator) -> Array< decltype(generator()), N >
	Generate an array using the given generator. More...

template<class T , size_t N, class U >
Array< T, N >	copyAs (const Array< U, N > &src)
	Copy an Array to an Array of a different type. More...

template<class F , class U , size_t N>
Array< decltype(F{}(U{})), N >	apply (const Array< U, N > &src, F f)
	Apply a function to all elements of the array and return a copy.

template<class T , size_t N, class... Args>
Array< T, N >	fillArray (Args... args)
	Fill the array with the same value for each element.

template<class T , size_t N, class U , class V = U>
Array< T, N >	generateIncrementalArray (U start=0, V increment=V(1))
	Generate an array where the first value is given, and the subsequent values are calculated as the previous value incremented with a given value: \( x[0] = \mathrm{start} \) \( x[k+1] = x[k] + \mathrm{increment} \) . More...

template<class T , size_t M, size_t N>
Array< T, M+N >	cat (const Array< T, M > &a, const Array< T, N > &b)
	Concatenate two arrays. More...

template<class T1 , class T2 , size_t N1, size_t N2, bool Reverse1, bool Reverse2, bool Const1, bool Const2>
Array< decltype(T1() *T2()), N1+N2 - 1 >	distribute (const ArraySlice< T1, N1, Reverse1, Const1 > &a, const ArraySlice< T2, N2, Reverse2, Const2 > &b)

template<class T1 , class T2 , size_t N1, size_t N2, bool Reverse1, bool Const1>
Array< decltype(T1() *T2()), N1+N2 - 1 >	distribute (const ArraySlice< T1, N1, Reverse1, Const1 > &a, const Array< T2, N2 > &b)

template<class T1 , class T2 , size_t N1, size_t N2, bool Reverse2, bool Const2>
Array< decltype(T1() *T2()), N1+N2 - 1 >	distribute (const Array< T1, N1 > &a, const ArraySlice< T2, N2, Reverse2, Const2 > &b)

template<class T1 , class T2 , size_t N1, size_t N2>
Array< decltype(T1() *T2()), N1+N2 - 1 >	distribute (const Array< T1, N1 > &a, const Array< T2, N2 > &b)

template<class T , size_t N, bool Reverse, bool Const>
std::enable_if_t< std::is_arithmetic< T >::value, Print & >	operator<< (Print &os, const AH::ArraySlice< T, N, Reverse, Const > &a)

template<class T , size_t N>
std::enable_if_t< std::is_arithmetic< T >::value, Print & >	operator<< (Print &os, const AH::Array< T, N > &a)

void	fatalErrorExit () __attribute__((noreturn))
	Function that executes and loops forever, blinking the built-in LED when a fatal error is encountered.

template<class T >
constexpr std::enable_if< std::is_floating_point< T >::value, T >::type	rad2deg (T r)
	Convert radians to degrees.

template<class T >
constexpr std::enable_if< std::is_floating_point< T >::value, T >::type	deg2rad (T d)
	Convert degrees to radians.

template<size_t Bits_out, size_t Bits_in, class T_out , class T_in >
std::enable_if_t<(Bits_out<=2 *Bits_in), T_out >	increaseBitDepthImpl (T_in in)

template<size_t Bits_out, size_t Bits_in, class T_out , class T_in >
std::enable_if_t<(Bits_out > 2 *Bits_in), T_out >	increaseBitDepthImpl (T_in in)

template<size_t Bits_out, size_t Bits_in, class T_out , class T_in >
T_out	increaseBitDepth (T_in in)
	Increase the bit depth of the given value from `Bits_in` bits wide to `Bits_out` bits wide, (approximately) evenly distributing the error across the entire range, such that the error for each element is between -1 and +1. More...

template<class T , class U >
constexpr auto	min (const T &a, const U &b) -> decltype(b< a ? b :a)
	Return the smaller of two numbers/objects.

template<class T , class U >
constexpr auto	max (const T &a, const U &b) -> decltype(a< b ? b :a)
	Return the larger of two numbers/objects.

Print &	operator<< (Print &os, Quaternion q)

Print &	operator<< (Print &os, EulerAngles e)

template<class T >
Print &	printIntegral (Print &printer, T i)

Print &	endl (Print &printer)

Print &	uppercase (Print &printer)

Print &	nouppercase (Print &printer)

Print &	showbase (Print &printer)

Print &	noshowbase (Print &printer)

Print &	flush (Print &printer)

Print &	hex (Print &printer)

Print &	bin (Print &printer)

Print &	dec (Print &printer)

Print &	boolalpha (Print &printer)

Print &	noboolalpha (Print &printer)

Print &	leadingzeros (Print &printer)

Print &	noleadingzeros (Print &printer)

Print &	operator<< (Print &printer, const __FlashStringHelper *s)

Print &	operator<< (Print &printer, const String &s)

Print &	operator<< (Print &printer, const char s[])

Print &	operator<< (Print &printer, char c)

Print &	operator<< (Print &printer, unsigned char i)

Print &	operator<< (Print &printer, int i)

Print &	operator<< (Print &printer, unsigned int i)

Print &	operator<< (Print &printer, int8_t i)

Print &	operator<< (Print &printer, long i)

Print &	operator<< (Print &printer, unsigned long i)

Print &	operator<< (Print &printer, double d)

Print &	operator<< (Print &printer, float f)

Print &	operator<< (Print &printer, const Printable &p)

Print &	operator<< (Print &printer, bool b)

Print &	operator<< (Print &printer, manipulator pf)

Setbase	setbase (uint8_t base)

Print &	operator<< (Print &printer, Setbase f)

Setbytesep	setbytesep (char bytesep)

Print &	operator<< (Print &printer, Setbytesep f)

Setprecision	setprecision (int n)

Print &	operator<< (Print &printer, Setprecision f)

static char	nibble_to_hex (uint8_t nibble)

template<class T >
void	printHex (Print &printer, T val)

template<class T >
void	printBin (Print &printer, T val)

Print &	operator<< (Print &p, HexDump h)

Variables
constexpr pin_t	NO_PIN = 1 << (8 * sizeof(pin_t) - 1)
	A special pin number that indicates an unused or invalid pin.

static constexpr uint8_t	SevenSegmentCharacters [0x40]
	A lookup table for 7-segment characters, as specified by the Logic Control manual. More...

static constexpr const uint8_t *	AlphaChars = &SevenSegmentCharacters[0x01]

static constexpr const uint8_t *	NumericChars = &SevenSegmentCharacters[0x30]

constexpr static int8_t	MCP23017Encoders_lut [16]
	More...

uint8_t	formatPrintStream = DEC

bool	boolalphaPrintStream = false

bool	leadingZerosPrintStream = false

uint8_t	precisionPrintStream = 2

char	byteSeparatorPrintStream = '\0'

enum AH:: { ... }	casePrintStream = LOWERCASE

bool	showbasePrintStream = false

constexpr unsigned long	defaultBaudRate = 115200
	The default baud rate for debug output.

constexpr uint8_t	ADC_BITS = ADC_RESOLUTION
	The bit depth to use for the ADC (Analog to Digital Converter). More...

constexpr uint8_t	ANALOG_FILTER_SHIFT_FACTOR = 2
	The factor for the analog filter: Difference equation: \( y[n] = \alpha\cdot x[n] + (1-\alpha)\cdot y[n-1] \) where \( \alpha = \left(\frac{1}{2}\right)^{ANALOG\_FILTER\_SHIFT\_FACTOR} \). More...

constexpr unsigned long	BUTTON_DEBOUNCE_TIME = 25
	The debounce time for momentary push buttons in milliseconds.

constexpr unsigned long	LONG_PRESS_DELAY = 450
	The time in milliseconds before a press is registered as a long press.

constexpr unsigned long	LONG_PRESS_REPEAT_DELAY = 200
	The time between increments/decremnets during a long press.

constexpr unsigned long	FILTERED_INPUT_UPDATE_INTERVAL = 1000
	The interval between updating filtered analog inputs, in microseconds.

constexpr static Frequency	SPI_MAX_SPEED = 8_MHz

Class Documentation

◆ AH::function_traits

struct AH::function_traits

Collaboration diagram for function_traits< T >:

◆ AH::NormalUpdatable

struct AH::NormalUpdatable

Collaboration diagram for NormalUpdatable:

Typedef Documentation

◆ ANALOG_FILTER_TYPE

using ANALOG_FILTER_TYPE = uint16_t

The unsigned integer type to use for analog inputs during filtering.

See also: FilteredAnalog

Definition at line 71 of file AH/Settings/Settings.hpp.

Enumeration Type Documentation

◆ MCP23017RegAddr

enum MCP23017RegAddr

Enumerator
IODIRA
IODIRB
IPOLA
IPOLB
GPINTENA
GPINTENB
DEFVALA
DEFVALB
INTCONA
INTCONB
IOCON
GPPUA
GPPUB
INTFA
INTFB
INTCAPA
INTCAPB
GPIOA
GPIOB
OLATA
OLATB

Definition at line 5 of file MCP23017.ipp.

◆ DotBarMode

enum class DotBarMode : bool

strong

An enumeration type to set an LED display to either bar or dot mode.

Enumerator
Bar	Turn on a range of LEDs up to the active LED.
Dot	Turn on only the active LED.

Definition at line 15 of file DotBarDisplayLEDs.hpp.

◆ anonymous enum

anonymous enum : char

Enumerator
LOWERCASE
UPPERCASE

Definition at line 21 of file PrintStream.cpp.

Variable Documentation

◆ SevenSegmentCharacters

constexpr uint8_t SevenSegmentCharacters[0x40]

staticconstexpr

Initial value:

= {
    0b00000000, 0b01110111, 0b00011111, 0b01001110, 
    0b00111101, 0b01001111, 0b01000111, 0b01011110, 
    0b00010111, 0b00110000, 0b00111100, 0b00000111, 
    0b00001110, 0b01110110, 0b00010101, 0b00011101, 
    0b01100111, 0b01110011, 0b00000101, 0b01011011, 
    0b00001111, 0b00011100, 0b00100111, 0b00111110, 
    0b00110111, 0b00111011, 0b01101101, 0b01001110, 
    0b00010011, 0b01111000, 0b01100010, 0b00001000, 
    0b00000000, 0b00000000, 0b00100010, 0b01100011, 
    0b01011011, 0b01100111, 0b01111101, 0b00000010, 
    0b01001110, 0b01111000, 0b01100011, 0b00110001, 
    0b00000100, 0b00000001, 0b00001000, 0b00100101, 
    0b01111110, 0b00110000, 0b01101101, 0b01111001, 
    0b00110011, 0b01011011, 0b01011111, 0b01110000, 
    0b01111111, 0b01111011, 0b00000000, 0b01000100, 
    0b00110001, 0b00001001, 0b00000111, 0b01100101, 
}

A lookup table for 7-segment characters, as specified by the Logic Control manual.

A | | F | | B |__G__| | | E | | C |__D__| o DP

Definition at line 22 of file MAX7219SevenSegmentDisplay.hpp.

◆ MCP23017Encoders_lut

constexpr static int8_t MCP23017Encoders_lut[16]

staticconstexpr

Initial value:

= {
    0,  
    +1, 
    -1, 
    +2, 
    -1, 
    0,  
    -2, 
    +1, 
    +1, 
    -2, 
    0,  
    -1, 
    +2, 
    -1, 
    +1, 
    0,  
}

Definition at line 17 of file MCP23017Encoders.hpp.

◆ ADC_BITS

constexpr uint8_t ADC_BITS = ADC_RESOLUTION

constexpr

The bit depth to use for the ADC (Analog to Digital Converter).

By default, the maximum supported resolution is used, but if you need it for compatibility with other code that expects the default 10-bit resolution, you can use

constexpr uint8_t ADC_BITS = 10;

AH::ADC_BITS

constexpr uint8_t ADC_BITS

The bit depth to use for the ADC (Analog to Digital Converter).

Definition: AH/Settings/Settings.hpp:53

If the library doesn't know your specific hardware, it defaults to 10 bits. This might not be the optimal resolution, so it's best to add the actual resolution to Hardware/ADCConfig.hpp.

Definition at line 53 of file AH/Settings/Settings.hpp.

◆ ANALOG_FILTER_SHIFT_FACTOR

constexpr uint8_t ANALOG_FILTER_SHIFT_FACTOR = 2

constexpr

The factor for the analog filter:
Difference equation: \( y[n] = \alpha\cdot x[n] + (1-\alpha)\cdot y[n-1] \) where \( \alpha = \left(\frac{1}{2}\right)^{ANALOG\_FILTER\_SHIFT\_FACTOR} \).

See also: FilteredAnalog

Definition at line 64 of file AH/Settings/Settings.hpp.