• Avr-gcc Predefined Macros
• Avr Gcc Macros
• Avr Gcc Define Macro
• Avr-gcc Macports

For AVR® Development. CrossPack is a development environment for Atmel’s AVR® microcontrollers running on Apple’s Mac OS X, similar to AVR Studio on Windows. It consists of the GNU compiler suite, a C library for the AVR, the AVRDUDE uploader and several other useful tools. WinAVR TM contains all the tools for developing on the AVR. This includes avr-gcc (compiler), avrdude (programmer), avr-gdb (debugger), and more! WinAVR is used all over the world from hobbyists sitting in their damp basements, to schools, to commercial projects. WinAVR TM is comprised of many open source projects. If you feel adventurous. Download the Atmel AVR Toolchain for Windows from Atmel's site and run the installer. When asked where to extract the files, click the '.' Button and navigate to C:Program Files, then click Extract. Install GNU Make. Download Gnu Make and launch the installer. Accept the default location for the installation.

Winavr for mac free download. Winavrportable WinAVR-portable is based on regular WinAVR AVR-GCC for windows for the Atmel AVR microcontroller s. Mac OS; Windows; Ubuntu Software Install Get and install avrdude / GCC software and dependencies: Open Terminal and type: sudo apt-get install flex byacc bison gcc libusb-dev avrdude Then type: sudo apt-get install gcc-avr - type 'y' when asked to do so by your system Then type: sudo apt-get install avr-libc.

Hello,

I've been programming on Arduino for sometime, and now I am starting to learn how to program the ATmega328 using AVR-C and an AVR programmer..

unfortunately it seems the process is a bit more complicated on mac (I am currently using OS X El capitan version 10.11.6) since there's no Atmel studio on mac.

I've found some resources online but it seems many of them are outdated.

so my question is, is anyone here doing AVR programming on mac? and I'd really appreciate it if anyone can provide me with links for the tools I need (IDE, etc..) so I can start writing C code and upload them to the ATMega through the USB AVR programmer that I have.

Thanks,

Next: Blackfin Options, Previous: ARM Options, Up: Submodel Options [Contents][Index]

3.19.6 AVR Options

These options are defined for AVR implementations:

Specify Atmel AVR instruction set architectures (ISA) or MCU type.

The default for this option is ‘avr2’.

GCC supports the following AVR devices and ISAs:

“Classic” devices with up to 8 KiB of program memory.
mcu = attiny22, attiny26, at90s2313, at90s2323, at90s2333, at90s2343, at90s4414, at90s4433, at90s4434, at90c8534, at90s8515, at90s8535.

“Classic” devices with up to 8 KiB of program memory and with the MOVW instruction.
mcu = attiny13, attiny13a, attiny24, attiny24a, attiny25, attiny261, attiny261a, attiny2313, attiny2313a, attiny43u, attiny44, attiny44a, attiny45, attiny48, attiny441, attiny461, attiny461a, attiny4313, attiny84, attiny84a, attiny85, attiny87, attiny88, attiny828, attiny841, attiny861, attiny861a, ata5272, ata6616c, at86rf401.

“Classic” devices with 16 KiB up to 64 KiB of program memory.
mcu = at76c711, at43usb355.

“Classic” devices with 128 KiB of program memory.
mcu = atmega103, at43usb320.

“Classic” devices with 16 KiB up to 64 KiB of program memory and with the MOVW instruction.
mcu = attiny167, attiny1634, atmega8u2, atmega16u2, atmega32u2, ata5505, ata6617c, ata664251, at90usb82, at90usb162.

“Enhanced” devices with up to 8 KiB of program memory.
mcu = atmega48, atmega48a, atmega48p, atmega48pa, atmega48pb, atmega8, atmega8a, atmega8hva, atmega88, atmega88a, atmega88p, atmega88pa, atmega88pb, atmega8515, atmega8535, ata6285, ata6286, ata6289, ata6612c, at90pwm1, at90pwm2, at90pwm2b, at90pwm3, at90pwm3b, at90pwm81.

“Enhanced” devices with 16 KiB up to 64 KiB of program memory.
mcu = atmega16, atmega16a, atmega16hva, atmega16hva2, atmega16hvb, atmega16hvbrevb, atmega16m1, atmega16u4, atmega161, atmega162, atmega163, atmega164a, atmega164p, atmega164pa, atmega165, atmega165a, atmega165p, atmega165pa, atmega168, atmega168a, atmega168p, atmega168pa, atmega168pb, atmega169, atmega169a, atmega169p, atmega169pa, atmega32, atmega32a, atmega32c1, atmega32hvb, atmega32hvbrevb, atmega32m1, atmega32u4, atmega32u6, atmega323, atmega324a, atmega324p, atmega324pa, atmega325, atmega325a, atmega325p, atmega325pa, atmega328, atmega328p, atmega328pb, atmega329, atmega329a, atmega329p, atmega329pa, atmega3250, atmega3250a, atmega3250p, atmega3250pa, atmega3290, atmega3290a, atmega3290p, atmega3290pa, atmega406, atmega64, atmega64a, atmega64c1, atmega64hve, atmega64hve2, atmega64m1, atmega64rfr2, atmega640, atmega644, atmega644a, atmega644p, atmega644pa, atmega644rfr2, atmega645, atmega645a, atmega645p, atmega649, atmega649a, atmega649p, atmega6450, atmega6450a, atmega6450p, atmega6490, atmega6490a, atmega6490p, ata5795, ata5790, ata5790n, ata5791, ata6613c, ata6614q, ata5782, ata5831, ata8210, ata8510, ata5702m322, at90pwm161, at90pwm216, at90pwm316, at90can32, at90can64, at90scr100, at90usb646, at90usb647, at94k, m3000.

“Enhanced” devices with 128 KiB of program memory.
mcu = atmega128, atmega128a, atmega128rfa1, atmega128rfr2, atmega1280, atmega1281, atmega1284, atmega1284p, atmega1284rfr2, at90can128, at90usb1286, at90usb1287.

“Enhanced” devices with 3-byte PC, i.e. with more than 128 KiB of program memory.
mcu = atmega256rfr2, atmega2560, atmega2561, atmega2564rfr2.

“XMEGA” devices with more than 8 KiB and up to 64 KiB of program memory.
mcu = atxmega8e5, atxmega16a4, atxmega16a4u, atxmega16c4, atxmega16d4, atxmega16e5, atxmega32a4, atxmega32a4u, atxmega32c3, atxmega32c4, atxmega32d3, atxmega32d4, atxmega32e5.

“XMEGA” devices with up to 64 KiB of combined program memory and RAM, and with program memory visible in the RAM address space.
mcu = attiny202, attiny204, attiny212, attiny214, attiny402, attiny404, attiny406, attiny412, attiny414, attiny416, attiny417, attiny804, attiny806, attiny807, attiny814, attiny816, attiny817, attiny1604, attiny1606, attiny1607, attiny1614, attiny1616, attiny1617, attiny3214, attiny3216, attiny3217, atmega808, atmega809, atmega1608, atmega1609, atmega3208, atmega3209, atmega4808, atmega4809.

“XMEGA” devices with more than 64 KiB and up to 128 KiB of program memory.
mcu = atxmega64a3, atxmega64a3u, atxmega64a4u, atxmega64b1, atxmega64b3, atxmega64c3, atxmega64d3, atxmega64d4.

“XMEGA” devices with more than 64 KiB and up to 128 KiB of program memory and more than 64 KiB of RAM.
mcu = atxmega64a1, atxmega64a1u.

“XMEGA” devices with more than 128 KiB of program memory.
mcu = atxmega128a3, atxmega128a3u, atxmega128b1, atxmega128b3, atxmega128c3, atxmega128d3, atxmega128d4, atxmega192a3, atxmega192a3u, atxmega192c3, atxmega192d3, atxmega256a3, atxmega256a3b, atxmega256a3bu, atxmega256a3u, atxmega256c3, atxmega256d3, atxmega384c3, atxmega384d3.

“XMEGA” devices with more than 128 KiB of program memory and more than 64 KiB of RAM.
mcu = atxmega128a1, atxmega128a1u, atxmega128a4u.

“TINY” Tiny core devices with 512 B up to 4 KiB of program memory.
mcu = attiny4, attiny5, attiny9, attiny10, attiny20, attiny40.

This ISA is implemented by the minimal AVR core and supported for assembler only.
mcu = attiny11, attiny12, attiny15, attiny28, at90s1200.

Assume that all data in static storage can be accessed by LDS / STSinstructions. This option has only an effect on reduced Tiny devices likeATtiny40. See also the absdatavariable attribute.

Accumulate outgoing function arguments and acquire/release the neededstack space for outgoing function arguments once in functionprologue/epilogue. Without this option, outgoing arguments are pushedbefore calling a function and popped afterwards.

Popping the arguments after the function call can be expensive onAVR so that accumulating the stack space might lead to smallerexecutables because arguments need not be removed from thestack after such a function call.

This option can lead to reduced code size for functions that performseveral calls to functions that get their arguments on the stack likecalls to printf-like functions.

Set the branch costs for conditional branch instructions tocost. Reasonable values for cost are small, non-negativeintegers. The default branch cost is 0.

Functions prologues/epilogues are expanded as calls to appropriatesubroutines. Code size is smaller.

Set the size (in bits) of the double or long double type,respectively. Possible values for bits are 32 and 64.Whether or not a specific value for bits is allowed depends onthe --with-double= and --with-long-double=configure options,and the same applies for the default values of the options.

Interrupt service routines (ISRs) may use the __gcc_isr pseudoinstruction supported by GNU Binutils.If this option is on, the feature can still be disabled for individualISRs by means of the no_gccisrfunction attribute. This feature is activated per defaultif optimization is on (but not with -Og, see Optimize Options),and if GNU Binutils support PR21683.

Assume int to be 8-bit integer. This affects the sizes of all types: achar is 1 byte, an int is 1 byte, a long is 2 bytes,and long long is 4 bytes. Please note that this option does notconform to the C standards, but it results in smaller codesize.

Do not save registers in main. The effect is the same likeattaching attribute OS_taskto main. It is activated per default if optimization is on.

Assume that the flash memory has a size of num times 64 KiB.

Generated code is not compatible with hardware interrupts.Code size is smaller.

Try to replace CALL resp. JMP instruction by the shorterRCALL resp. RJMP instruction if applicable.Setting -mrelax just adds the --mlink-relax option tothe assembler’s command line and the --relax option to thelinker’s command line.

Jump relaxing is performed by the linker because jump offsets are notknown before code is located. Therefore, the assembler code generated by thecompiler is the same, but the instructions in the executable maydiffer from instructions in the assembler code.

Relaxing must be turned on if linker stubs are needed, see thesection on EIND and linker stubs below.

Assume that the device supports the Read-Modify-Writeinstructions XCH, LAC, LAS and LAT.

Assume that RJMP and RCALL can target the wholeprogram memory.

This option is used internally for multilib selection. It isnot an optimization option, and you don’t need to set it by hand.

Treat the stack pointer register as an 8-bit register,i.e. assume the high byte of the stack pointer is zero.In general, you don’t need to set this option by hand.

This option is used internally by the compiler to select andbuild multilibs for architectures avr2 and avr25.These architectures mix devices with and without SPH.For any setting other than -mmcu=avr2 or -mmcu=avr25the compiler driver adds or removes this option from the compilerproper’s command line, because the compiler then knows if the deviceor architecture has an 8-bit stack pointer and thus no SPHregister or not.

Use address register X in a way proposed by the hardware. This meansthat X is only used in indirect, post-increment orpre-decrement addressing.

Without this option, the X register may be used in the same wayas Y or Z which then is emulated by additionalinstructions. For example, loading a value with X+const addressing with asmall non-negative const < 64 to a register Rn isperformed as

Only change the lower 8 bits of the stack pointer.

Allow to use truncation instead of rounding towards zero for fractional fixed-point types.

Don’t link against AVR-LibC’s device specific library lib<mcu>.a.

Don’t add -specs=device-specs/specs-mcu to the compiler driver’scommand line. The user takes responsibility for supplying the sub-processeslike compiler proper, assembler and linker with appropriate command lineoptions. This means that the user has to supply her private device specsfile by means of -specs=path-to-specs-file. There is nomore need for option -mmcu=mcu.

This option can also serve as a replacement for the older way ofspecifying custom device-specs files that needed -B some-path to point to a directorywhich contains a folder named device-specs which contains a specs file namedspecs-mcu, where mcu was specified by -mmcu=mcu.

Warn about conversions between address spaces in the case where theresulting address space is not contained in the incoming address space.

Warn if the ISR is misspelled, i.e. without __vector prefix.Enabled by default.

3.19.6.1 EIND and Devices with More Than 128 Ki Bytes of Flash

Pointers in the implementation are 16 bits wide.The address of a function or label is represented as word address sothat indirect jumps and calls can target any code address in therange of 64 Ki words.

In order to facilitate indirect jump on devices with more than 128 Kibytes of program memory space, there is a special function register calledEIND that serves as most significant part of the target addresswhen EICALL or EIJMP instructions are used.

Indirect jumps and calls on these devices are handled as follows bythe compiler and are subject to some limitations:

• The compiler never sets EIND.
• The compiler uses EIND implicitly in EICALL/EIJMPinstructions or might read EIND directly in order to emulate anindirect call/jump by means of a RET instruction.
• The compiler assumes that EIND never changes during the startupcode or during the application. In particular, EIND is notsaved/restored in function or interrupt service routineprologue/epilogue.
• For indirect calls to functions and computed goto, the linkergenerates stubs. Stubs are jump pads sometimes also calledtrampolines. Thus, the indirect call/jump jumps to such a stub.The stub contains a direct jump to the desired address.
• Linker relaxation must be turned on so that the linker generatesthe stubs correctly in all situations. See the compiler option-mrelax and the linker option --relax.There are corner cases where the linker is supposed to generate stubsbut aborts without relaxation and without a helpful error message.
• The default linker script is arranged for code with EIND = 0.If code is supposed to work for a setup with EIND != 0, a customlinker script has to be used in order to place the sections whosename start with .trampolines into the segment where EINDpoints to.
• The startup code from libgcc never sets EIND.Notice that startup code is a blend of code from libgcc and AVR-LibC.For the impact of AVR-LibC on EIND, see theAVR-LibC user manual.
• It is legitimate for user-specific startup code to set up EINDearly, for example by means of initialization code located insection .init3. Such code runs prior to general startup codethat initializes RAM and calls constructors, but after the bitof startup code from AVR-LibC that sets EIND to the segmentwhere the vector table is located.

  The __trampolines_start symbol is defined in the linker script.

• Stubs are generated automatically by the linker ifthe following two conditions are met:
  • - The address of a label is taken by means of the gs modifier(short for generate stubs) like so:
  • - The final location of that label is in a code segmentoutside the segment where the stubs are located.
• The compiler emits such gs modifiers for code labels in thefollowing situations:
  • - Taking address of a function or code label.
  • - Computed goto.
  • - If prologue-save function is used, see -mcall-prologuescommand-line option.
  • - Switch/case dispatch tables. If you do not want such dispatchtables you can specify the -fno-jump-tables command-line option.
  • - C and C++ constructors/destructors called during startup/shutdown.
  • - If the tools hit a gs() modifier explained above.
• Jumping to non-symbolic addresses like so is not supported:

  Instead, a stub has to be set up, i.e. the function has to be calledthrough a symbol (func_4 in the example):

  and the application be linked with -Wl,--defsym,func_4=0x4.Alternatively, func_4 can be defined in the linker script.

3.19.6.2 Handling of the RAMPD, RAMPX, RAMPY and RAMPZ Special Function Registers

Some AVR devices support memories larger than the 64 KiB rangethat can be accessed with 16-bit pointers. To access memory locationsoutside this 64 KiB range, the content of a RAMPregister is used as high part of the address:The X, Y, Z address register is concatenatedwith the RAMPX, RAMPY, RAMPZ special functionregister, respectively, to get a wide address. Similarly,RAMPD is used together with direct addressing.

• The startup code initializes the RAMP special functionregisters with zero.
• If a named address space other thangeneric or __flash is used, then RAMPZ is setas needed before the operation.
• If the device supports RAM larger than 64 KiB and the compilerneeds to change RAMPZ to accomplish an operation, RAMPZis reset to zero after the operation.
• If the device comes with a specific RAMP register, the ISRprologue/epilogue saves/restores that SFR and initializes it withzero in case the ISR code might (implicitly) use it.
• RAM larger than 64 KiB is not supported by GCC for AVR targets.If you use inline assembler to read from locations outside the16-bit address range and change one of the RAMP registers,you must reset it to zero after the access.

3.19.6.3 AVR Built-in Macros

GCC defines several built-in macros so that the user code can testfor the presence or absence of features. Almost any of the followingbuilt-in macros are deduced from device capabilities and thustriggered by the -mmcu= command-line option.

For even more AVR-specific built-in macros seeAVR Named Address Spaces and AVR Built-in Functions.

Build-in macro that resolves to a decimal number that identifies thearchitecture and depends on the -mmcu=mcu option.Possible values are:

2, 25, 3, 31, 35,4, 5, 51, 6

for mcu=avr2, avr25, avr3, avr31,avr35, avr4, avr5, avr51, avr6,

respectively and

100,102, 103, 104,105, 106, 107

for mcu=avrtiny,avrxmega2, avrxmega3, avrxmega4,avrxmega5, avrxmega6, avrxmega7, respectively.If mcu specifies a device, this built-in macro is setaccordingly. For example, with -mmcu=atmega8 the macro isdefined to 4.

Setting -mmcu=device defines this built-in macro which reflectsthe device’s name. For example, -mmcu=atmega8 defines thebuilt-in macro __AVR_ATmega8__, -mmcu=attiny261a defines__AVR_ATtiny261A__, etc.

The built-in macros’ names followthe scheme __AVR_Device__ where Device isthe device name as from the AVR user manual. The difference betweenDevice in the built-in macro and device in-mmcu=device is that the latter is always lowercase.

If device is not a device but only a core architecture like‘avr51’, this macro is not defined.

Setting -mmcu=device defines this built-in macro tothe device’s name. For example, with -mmcu=atmega8 the macrois defined to atmega8.

If device is not a device but only a core architecture like‘avr51’, this macro is not defined.

The device / architecture belongs to the XMEGA family of devices.

The device has the ELPM instruction.

The device has the ELPM Rn,Z and ELPMRn,Z+ instructions.

The device has the MOVW instruction to perform 16-bitregister-register moves.

The device has the LPM Rn,Z andLPM Rn,Z+ instructions.

The device has a hardware multiplier.

The device has the JMP and CALL instructions.This is the case for devices with more than 8 KiB of programmemory.

Avr-gcc Predefined Macros

The device has the EIJMP and EICALL instructions.This is the case for devices with more than 128 KiB of program memory.This also means that the program counter(PC) is 3 bytes wide.

The program counter (PC) is 2 bytes wide. This is the case for deviceswith up to 128 KiB of program memory.

The stack pointer (SP) register is treated as 8-bit respectively16-bit register by the compiler.The definition of these macros is affected by -mtiny-stack.

The device has the SPH (high part of stack pointer) special functionregister or has an 8-bit stack pointer, respectively.The definition of these macros is affected by -mmcu= andin the cases of -mmcu=avr2 and -mmcu=avr25 alsoby -msp8.

The device has the RAMPD, RAMPX, RAMPY,RAMPZ special function register, respectively.

This macro reflects the -mno-interrupts command-line option.

Some AVR devices (AT90S8515, ATmega103) must not skip 32-bitinstructions because of a hardware erratum. Skip instructions areSBRS, SBRC, SBIS, SBIC and CPSE.The second macro is only defined if __AVR_HAVE_JMP_CALL__ is alsoset.

The device has Read-Modify-Write instructions (XCH, LAC, LAS and LAT).

Avr Gcc Macros

Instructions that can address I/O special function registers directlylike IN, OUT, SBI, etc. may use a differentaddress as if addressed by an instruction to access RAM like LDor STS. This offset depends on the device architecture and hasto be subtracted from the RAM address in order to get therespective I/O address.

The -mshort-calls command line option is set.

Some devices support reading from flash memory by means of LD*instructions. The flash memory is seen in the data address spaceat an offset of __AVR_PM_BASE_ADDRESS__. If this macrois not defined, this feature is not available. If defined,the address space is linear and there is no need to put.rodata into RAM. This is handled by the default linkerdescription file, and is currently available foravrtiny and avrxmega3. Even more convenient,there is no need to use address spaces like __flash orfeatures like attribute progmem and pgm_read_*.

The compiler is configured to be used together with AVR-Libc.See the --with-avrlibc configure option.

Defined if -mdouble= acts as a multilib option.

Defined if the compiler supports 32-bit double resp. 64-bit double.The actual layout is specified by option -mdouble=.

The size in bits of double if -mdouble= is not set.To test the layout of double in a program, use the built-inmacro __SIZEOF_DOUBLE__.

Same as above, but for long double instead of double.

Reflects the --with-double-comparison={tristate|bool|libf7}configure optionand is defined to 2 or 3.

Avr Gcc Define Macro

Reflects the --with-libf7={libgcc|math|math-symbols}configure option.

Avr-gcc Macports

Next: Blackfin Options, Previous: ARM Options, Up: Submodel Options [Contents][Index]