AVR libc function reference

This file gives an overview of the C library functions implemented in the avr-libc standard library for the Atmel AVR microcontroller family.

As of the writing of this reference, the current version of avr-libc was 20010821.

avr-libc is maintained by Marek Michalkiewicz <marekm@linux.org.pl>.

This document is written by Enno Luebbers <luebbers@users.sourceforge.net>. I do not take any responsibility about what happens if you use the information in this reference. You are on your own. :) Formally that means:

This document is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY DISCLAIMED. This includes but is not limited to warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Documentation for most of the functions that are not hardware specific to the AVR architecture (like I/O ports or interrupt handlers) can be found in the Linux manpages.

Thanks go to Jörg Wunsch for pointing me to several errors in previous versions of this reference and for including it in the FreeBSD Port of the avr-libc. Also thanks to Jochen Pernsteiner for his explanation of strlwr() and to Peter N Lewis for his help about SIGNAL() and INTERRUPT().

Function list by Header files

Alphabetical function list

void	abort();
double	acos( double x );
double	asin( double x );
double	atan( double x );
long	atoi( char *p );
long	atol( char *p );
	bit_is_clear( port, bit );
	bit_is_set( port, bit );
void	bsearch(const void *key, const void *base, size_t nmemb,
	BV( x );
	cbi( port, bit );
double	ceil( doublce x );
	cli();
double	cos( double x );
double	cosh( double x );
div_t	div( int x, int y );
int	eeprom_is_ready()
unsigned char	eeprom_rb(unsigned int addr);
void	eeprom_read_block(void *buf, unsigned int addr, size_t n);
unsigned int	eeprom_rw(unsigned int addr);
void	eeprom_wb(unsigned int addr, unsigned char val);
void	enable_external_int( unsigned char ints );
int	errno();
double	exp( double x );
double	fabs( double x );
double	floor( double x );
double	fmod( double x, double y );
void	free( void *ptr );
double	frexp( double x, int *exp );
	inp( port );
	INTERRUPT( signame );
double	inverse( double x );
int	isalnum(int __c);
int	isalpha(int __c);
int	isascii(int __c);
int	iscntrl(int __c);
int	isdigit(int __c);
int	isgraph(int __c);
int	islower(int __c);
int	isprint(int __c);
int	ispunct(int __c);
int	isspace(int __c);
int	isupper(int __c);
int	isxdigit(int __c);
char	itoa( int value, char *string, int radix ) {
long	labs( long x );
double	ldexp( double x, int exp );
ldiv_t	ldiv( lomg x, long y );
double	log( double x );
double	log10( double x );
void	longjmp( jmp_buf env, int val );
	loop_until_bit_is_clear( port, bit );
	loop_until_bit_ist_set( port, bit );
void	malloc( size_t size );
void	memchr( void *s, char c, size_t n );
int	memcmp( const void *s1, const void *s2, size_t n );
void	memcpy( void *to, void *from, size_t n );
void	memmove( void *to, void *from, size_t n );
void	memset( void *s, int c, size_t n );
double	modf( double x, double *iptr );
	outp( value, port );
	parity_even_bit( val );
double	pow( double x, double y );
void	qsort(void *base, size_t nmemb, size_t size, __compar_fn_t compar);
	sbi( port, bit );
	sei();
int	setjmp( jmp_buf env );
	SIG_ADC(
	SIG_COMPARATOR(
	SIG_EEPROM(
	SIG_INPUT_CAPTURE1(
	SIG_INTERRUPT0 through SIG_INTERRUPT7
	SIG_OUTPUT_COMPARE0
	SIG_OUTPUT_COMPARE1A
	SIG_OUTPUT_COMPARE1B
	SIG_OUTPUT_COMPARE2
	SIG_OVERFLOW0
	SIG_OVERFLOW1
	SIG_OVERFLOW2
	SIG_SPI
	SIG_UART1_DATA
	SIG_UART1_RECV
	SIG_UART1_TRANS
	SIG_UART_DATA
	SIG_UART_RECV
	SIG_UART_TRANS
	SIGNAL( signame );
double	sin( double x );
double	sinh( double x );
double	sqrt( double x );
double	square( double x );
extern int	strcasecmp(const char *s1, const char *s2);
char	strcat( char *dest, char *src );
char	strchr( const char *s, int c );
int	strcmp( const char *s1, const char* s2 );
char	strcpy( char *dest, char *src );
	strdupa( s );
size_t	strlen( char *s );
extern char	strlwr(char *);
extern int	strncasecmp(const char *, const char *, size_t);
char	strncat( char *dest, char *src, size_t n );
int	strncmp( const char *s1, const char* s2, size_t n );
char	strncpy( char *dest, char *src, size_t n );
	strndupa( s, n );
size_t	strnlen( const char *s, size_t maxlen );
char	strrchr( const char *s, int c );
extern char	strrev(char *s1);
extern char	strstr(const char *haystack, const char *needle);
double	strtod( char *, char ** );
double	strtod( const char *s, char **endptr );
long	strtol(const char *nptr, char **endptr, int base);
unsigned long	strtoul(const char *nptr, char **endptr, int base);
extern char	strupr(char *);
double	tan( double x );
double	tanh( double x );
void	timer0_source( unsigned int src );
coid	timer0_start();
void	timer0_stop();
void	timer_enable_int( unsigned char ints );
int	toascii(int __c);
int	tolower(int __c);
int	toupper(int __c);
	wdt_disable();
	wdt_enable( timeout );
	wdt_reset();

This header file contains some compatibility functions and macros to make porting applications from the IAR C compiler to avr-gcc easier. Since you wouldn't use it for writing new applications, there's no need for documentation here (lazy me).

Defines the following types:

Be careful with the -mint8 option, though.

Automagically includes the ioXXX.h header file for the target AVR microcontroller.

Just includes both io-avr.h and iomacros.h.

I/O-register definitions for the XXX MCU. Refer to the specific datasheet for a description of the registers and their functions.

Constants:

Another compatibility header file for the IAR C compiler. Contains (or is suposed to contain) things like memcpy_P, strcat_P, printf_P etc.

Since it's a compatibility header file, I chose not to document it. Yet.

Includes pgmspace.h.

Defines symbols for the interrupt vectors that are stored at the begining of the flash memory. Defined are:

SIG_INTERRUPT0 through SIG_INTERRUPT7	Handler function name for the external interrupts 0 through 7. Interrupts > 1 are only available on certain ATmega AVRs.
SIG_OUTPUT_COMPARE2	Handler function name for the Compare2 interrupt (Analog Comparator).
SIG_OVERFLOW2	Handler function name for the Overflow2 interrupt.
SIG_INPUT_CAPTURE1	Handler function name for the Capture1 interrupt.
SIG_OUTPUT_COMPARE1A	Handler function name for the Compare1(A) interrupt.
SIG_OUTPUT_COMPARE1B	Handler function name for the Compare1(B) interrupt.
SIG_OVERFLOW1	Handler function name for the Overflow1 interrupt.
SIG_OUTPUT_COMPARE0	Handler function name for the Compare0 interrupt.
SIG_OVERFLOW0	Handler function name for the Overflow0 interrupt.
SIG_SPI	Handler function name for the SPI interrupt.
SIG_UART_RECV	Handler function name for the UART(0) Receive Complete interrupt.
SIG_UART1_RECV	Handler function name for the UART1 Receive Complete interrupt. UART1 is only available on the ATmega161.
SIG_UART_DATA	Handler function name for the UART(0) Data Register Empty interrupt.
SIG_UART1_DATA	Handler function name for the UART1 Data Register Empty interrupt. UART1 is only available on the ATmega161.
SIG_UART_TRANS	Handler function name for the UART(0) Transmit Complete interrupt.
SIG_UART1_TRANS	Handler function name for the UART1 Transmit Complete interrupt. UART1 is only available on the ATmega161.
SIG_ADC	Handler function name for the ADC Comversion Complete interrupt.
SIG_EEPROM	Handler function name for the EEPROM Ready interrupt.
SIG_COMPARATOR	Handler function name for the Analog Comparator interrupt.

Furthermore, the following functions/macros are defined:

In a handler defined with SIGNAL(), additional interrupts are implicitly forbidden, whereas in an INTERRUPT() handler, the first (implicit) instruction is "sei", so that additional interrupts can occur.

Thanks to Jörg Wunsch for correcting me there.

Includes sig-avr.h. You should use sig-avr.h directly, because signal.h might disappear shortly because it conflicts with the "real" ANSI C signal.h.

Defines the following types:

Additionally, the following functions/macros are declared:

The following functions are not yet implemented:

atexit(), atof(), calloc(), rand(), realloc(), srand();

Defines an enumeration for the Timer Control Register:

And there are the following functions:

void timer0_source( unsigned int src );	Writes 'src' into the TCCR0 register.
void timer0_stop();	Stops Timer 0 by clearing the TCNT0 register.
coid timer0_start();	Starts Timer 0 by writing a 1 into the TCNT0 register.

Defines several constants for the ATmega163.