Mikrocontroller.net - Benutzerbeiträge [de]

ARM-ASM-Tutorial

2019-10-10T19:06:22Z

Mthomas: /* Data processing */

[[Kategorie:ARM]][[Kategorie:STM32]][[Kategorie:Entwicklungstools]][[Kategorie:Programmiersprachen]]The [[ARM]] processor architecture is widely used in all kinds of industrial applications and also a significant number of hobby and maker projects. This tutorial aims to teach the fundamentals of programming ARM processors in assembly language.

Tutorial by [[Benutzer:Erlkoenig|Niklas Gürtler]]. [https://www.mikrocontroller.net/topic/482409 Thread in Forum] for feedback and questions.

== Introduction ==
=== Why assembly? ===
Today, there is actually little reason to use assembly language for entire projects, because high-quality optimizing compilers for high-level languages (especially C and C++) are readily available as free open source software and because the ARM architecture is specifically optimized for high-level languages. However, knowledge in assembly is still useful for debugging certain problems, writing low-level software such as bootloaders and operating system kernels, and reverse engineering software for which no source code is available. Occasionally it is necessary to manually optimize some performance-critical code section. Sometimes claims are made that ARM processors can’t be programmed in assembly. Therefore, this tutorial will show that this is very well possible by showing how to write entire (small) applications entirely in the ARM assembly language!

As most of the resources and tools for ARM focus on C programming and because of the complexity of the ARM ecosystem, the largest difficulty in getting started with ARM assembly is not the language itself, but rather using the tools correctly and finding relevant documentation. Therefore, this tutorial will focus on the development environment and how the written assembly code is transformed into the final program. With a good understanding of the environment, all the ARM instructions can be learned simply by reading the architecture documentation.

Because of the complex ecosystem around ARM, a general introduction of the ARM processor market is necessary.

=== About ARM ===
Arm Holdings is the company behind the ARM architecture. Arm does not manufacture any processors themselves, but designs the “blueprints” for processor cores, which are then licensed by various semiconductor companies such as ST, TI, NXP and many others, who combine the processor with various support hardware (most notably flash and RAM memories) and peripheral modules to produce a final complete processor IC. Some of these peripheral modules are even licensed from other companies – for example, the USB controller modules by Synopsys are found in many different processors from various manufacturers.

Because of this licensing model, ARM processor cores are found in a very large variety of products for which software can be developed using a single set of tools (especially compiler, assembler and debugger). This makes knowledge about the ARM architecture, particularly the ARM assembly language, useful for a large range of applications.

Since the ARM processor cores always require additional hardware modules to function, both the ARM-made processor core and the manufacturer-specific periphery modules have to be considered when developing software for ARM systems. For example, the instruction set is defined by ARM and software tools (compiler, assembler) need to be configured for the correct instruction set version, while the clock configuration is manufacturer-specific and needs to be addressed by initialization code specifically made for one processor.

=== Architecture and processor variants ===
A processor’s architecture defines the interface between hardware and software. Its most important part is the instruction set, but it also defines e.g. hardware behavior under exceptional circumstances (e.g. memory access errors, division by zero, etc.). Processor architectures evolve, so they have multiple versions and variants. They also define optional functionality that may or may not be present in a processor (e.g. a floating-point unit). For ARM, the architectures are documented exhaustively in the “ARM Architecture Reference Manuals”.

While the architecture is an abstract concept, a processor core is a concrete definition of a processor (e.g. as a silicon layout or HDL) that implements a certain architecture. Code that only uses knowledge of the architecture (e.g. an algorithm that does not access any periphery) will run on any processor implementing this architecture. Arm, as mentioned, designs processor cores for their own architectures, but some companies develop custom processors that conform to an ARM architecture, for example Apple and Qualcomm.

ARM architectures are numbered, starting with ARMv1 up until the most recent ARMv8. ARMv6 is the oldest architecture still in significant use, while ARMv7 is the most widespread one. Suffixes are appended to the version to denote variants of the architecture; e.g. ARMv7-M is for small embedded systems while ARMv7-A for more powerful processors. ARMv7E-M adds digital signal processing capabilities including saturating and SIMD operations.

Older ARM processors are named ARM1, ARM2 …, while after ARM11 the name “Cortex” was introduced. The Cortex-M family, including e.g. Cortex-M3 and Cortex-M4 (implementing ARMv7-M and ARMv7E-M architecture, respectively) is designed for microcontrollers, where power consumption, memory size, chip size and latency are important. The Cortex-A family, including e.g. Cortex-A8 and Cortex-A17 (both implementing ARMv7-A architecture) is intended for powerful processors (called “application processors”) for e.g. multimedia and communication products, particularly smartphones and tablets. These processors have much more processing power, typically feature high-bandwidth interfaces to the external world, and are designed to be used with high-level operating systems, most notably Linux (and Android).

An overview of ARM processors and their implemented architecture version can be found on [https://en.wikipedia.org/wiki/ARM_architecture#Cores Wikipedia].
This tutorial will focus on the Cortex-M microcontrollers, as these are much easier to program without an operating system and because assembly language is less relevant on Cortex-A processors. However, the large range of ARM-based devices necessitates flexibility in the architecture specification and software tools, which sometimes complicates their use.

There is actually not a single, but three instruction sets for ARM processors:
* The “A32” instruction set for 32bit ARM architectures, also simply called “ARM” instruction set, favors speed over program memory consumption. All instructions are 4 bytes in size.
* The “A64” instruction set is for the new 64bit ARM processors
* The “T32” instruction set for 32bit ARM architectures, also known as “Thumb”, favors program memory consumption over speed. Most instructions are 2 bytes in size, and some are 4 bytes.

The 64bit Cortex-A application processors support all three instruction sets, while the 32bit ones only A32 and T32. The Cortex-M microcontrollers only support T32. Therefore, this tutorial will only talk about “thumb2”, the second version of the “T32” instruction set.

== Prerequisites ==
First, suitable hardware and software need to be selected for demonstrating the usage of assembly language. For this tutorial, the choice of the specific microcontroller is of no great significance. However, to ensure that the example codes are easily transferable to your setup, it is recommended to use the same components.

=== Mikrocontroller selection ===
For the microcontroller, an [https://www.st.com/en/microcontrollers-microprocessors/stm32f103c8.html STM32F103C8] or [https://www.st.com/en/microcontrollers-microprocessors/stm32f103rb.html STM32F103RB] by STMicroelectronics will be used. Both controllers are identical except for the flash size (64 KiB vs 128 KiB) and number of pins (48 vs 64). These controllers belong to ST’s “mainstream” entry-level- family and are quite popular among hobbyist developers with many existing online resources. Several development boards with these controllers are available, for example: [https://www.st.com/en/evaluation-tools/nucleo-f103rb.html Nucleo-F103], “[https://os.mbed.com/users/hudakz/code/STM32F103C8T6_Hello/ Blue Pill]” (search for “stm32f103c8t6” on AliExpress, Ebay or Amazon), [https://www.olimex.com/Products/Duino/STM32/OLIMEXINO-STM32/open-source-hardware Olimexino-STM32], [https://www.olimex.com/Products/ARM/ST/STM32-P103/ STM32-P103], [https://www.olimex.com/Products/ARM/ST/STM32-H103/ STM32-H103], [https://www.st.com/en/evaluation-tools/stm3210e-eval.html STM3210E-EVAL].

=== Processor type & documentation ===
First, the microcontroller manufacturer’s documentation is used to find out what kind of ARM processor core and architecture is used for the chosen chip. This information is used to find all the relevant documentation.

* The first source of information is the [https://www.st.com/resource/en/datasheet/stm32f103rb.pdf STM32F103RB/C8 datasheet]. According to the headline, this is a '''medium-density''' device. This term is ST-specific and denotes a product family with certain features. The very first paragraph states that this microcontroller uses a '''Cortex-M3''' processor core with 72 MHz. This document also contains the electrical characteristics and pinouts.
* The next important document is the [https://www.st.com/resource/en/reference_manual/cd00171190.pdf STM32F103 reference manual] that contains detailed descriptions of the periphery. Particularly, detailed information about periphery registers and bits can be found here.
* The [https://developer.arm.com/ip-products/processors/cortex-m/cortex-m3 ARM developer website] provides information about the Cortex-M3 processor core, particularly the [https://static.docs.arm.com/100165/0201/arm_cortexm3_processor_trm_100165_0201_01_en.pdf ARM Cortex-M3 Processor Technical Reference Manual]. According to chapter 1.5.3, this processor implements the '''ARMv7-M architecture'''.
* The architecture is documented in the [https://static.docs.arm.com/ddi0403/ed/DDI0403E_d_armv7m_arm.pdf ARMv7M Architecture Reference Manual]. Particularly, it contains the complete documentation of the instruction set.

For any serious STM32 development, you should be familiar with all these documents.

=== Debug adapter ===
There are many different ways of getting your program to run on an STM32 controller. A debug adapter is not only capable of writing software to the controller’s flash, but can also analyze the program’s behavior while it is running. This allows you to run the program one instruction at a time, analyze program flow and memory contents and find the cause of crashes. While it is not strictly necessary to use such a debugger, it can save a lot of time during development. Since entry-level models are available cheaply, not using one doesn’t even save money. Debuggers connect to a host PC via USB (some via Ethernet) and to the microcontroller (“target”) via JTAG oder SWD. While these two interfaces are closely related and perform the same function, SWD uses fewer pins (2 instead of 4, excluding reset and ground). Most STM32 controllers support JTAG, and all support SWD.

Documenting all possible way of flashing and debugging STM32 controllers is beyond the scope of this tutorial; a lot of information is already available online on that topic. Therefore, this tutorial will assume that the [https://www.st.com/en/development-tools/st-link-v2.html ST-Link] debug adapter by STMicroelectronics is used, which is cheap and popular among hobbyists. Some of the aforementioned boards even include an ST-Link adapter, which can also be used “stand-alone” to flash an externally connected microcontroller. The examples should work with other adapters as well; please consult the appropriate documentation on how to use them.

=== Development Software ===
On the software part, several tools are needed for developing microcontroller firmware. Using a complete Integrated Development Environment (IDE) saves time and simplifies repetitive steps but hides some important steps that are necessary to gain a basic understanding of the process. Therefore, this tutorial will show the usage of the basic command line tools to demonstrate the underlying principles. Of course, for productive development, using an IDE is a sensible choice. The tools presented will work on Windows, Linux and Mac OS X (untested).

First, a text editor for writing assembly code is needed. Any good editor such as Notepad++, gedit or Kate is sufficient. When using Windows, the [https://www.st.com/en/development-tools/stsw-link004.html ST-Link Utility] can be useful, but is not strictly required.

Next, an assembler toolchain is needed to translate the written assembly code into machine code. For this, the [https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm GNU Arm Embedded Toolchain] is used. This is a collection of open source tools for writing software in Assembly, C and C++ for Cortex-M microcontrollers. Even though the package is maintained by ARM, the software is created by a community of open-source developers. For this tutorial, only the contained applications “binutils” (includes assembler & linker) and “GDB” (debugger) are really needed, but if you later decide to work with C or C++ code, the contained compilers will come in handy. Apart from that, this package is also shipped as part of several IDEs such as SW4STM32, Atollic TrueSTUDIO, emIDE, Embedded Studio and even Arduino – so if you (later) wish to work with one of these, your assembly code will be compatible with it.

Another component is required to talk with the debug adapter. For the ST-Link, this is done by [http://openocd.org/ OpenOCD], which communicates with the adapter via USB. Other adapters such as the J-Link ship with their own software.

Lastly, a calculator that supports binary and hexadecimal modes can be very helpful. Both the default Gnome calculator and the Windows calculator (calc.exe) are suitable.

== Setup ==
Follow the instructions in the next chapters to set up your development environment.

=== Hardware ===
The only thing that needs to be done hardware-wise is connecting the debugger with your microcontroller. If you are using a development board with an integrated debugger (such as the Nucleo-F103), this is achieved by setting the jumpers accordingly (see the board’s documentation – for e.g. the Nucleo-F103, both “CN2” jumpers need to be connected). When using an external debugger, connect the “GND”, “JTMS/SWDIO” and “JTCK/SWCLK” pins of debugger and microcontroller. Connect the debugger’s “nRESET” (or “nTRST” if it only has that) pin to the microcontroller’s “NRST” input.

If your board has jumpers or solder bridges for the “BOOT0” pin, make sure that the pin is low. Applying power to the microcontroller board is typically done via USB.

=== Software ===
==== Linux ====
Some linux distributions ship with packages for the ARM toolchain. Unfortunately, these are often outdated and also configured slightly differently than the aforementioned package maintained by ARM. Therefore, to be consistent with the examples, it is strongly recommended to use the package by ARM.

Download the Linux binary tarball from the [https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads downloads page] and extract it to some directory whose path does not contain any spaces. The extracted directory contains a subdirectory called “bin”. Copy the full path to that directory (e.g. “/home/user/gcc-arm-none-eabi-8-2019-q3-update/bin”).

Add this path to the “PATH” environment variable. On Ubuntu/Debian systems, this can be done via:

<source lang=sh>
echo 'export PATH="${PATH}:/home/user/gcc-arm-none-eabi-8-2019-q3-update/bin"' | sudo tee /etc/profile.d/gnu-arm-embedded.sh
</source>

OpenOCD can be installed via the package manager, e.g. (Ubuntu/Debian):
<source lang=sh>
sudo apt-get install openocd
</source>

After that, log out and back in (or just reboot). In a terminal, type <code>arm-none-eabi-as -version</code>. The output should look similar to this:
<source lang=sh>
$ arm-none-eabi-as -version
GNU assembler (GNU Tools for Arm Embedded Processors 8-2019-q3-update) 2.32.0.20190703
Copyright (C) 2019 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or later.
This program has absolutely no warranty.
This assembler was configured for a target of `arm-none-eabi'.
</source>
Similarly, for <code>openocd -v</code>:
<source lang=sh>
$ openocd -v
Open On-Chip Debugger 0.10.0
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
</source>

If an error message appears, the installation isn’t correct.

==== Windows ====
[[File:ArmAsmTutorial_GccOptions.png|300px|thumb|right|Options for installing GCC]]Download the Windows installer from the [https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads downloads page] and run it. Enable the options “Add path to environment variable” and “Add registry information”, and disable “Show Readme” and “Launch gccvar.bat”.

A Windows package for OpenOCD can be obtained from the [https://github.com/gnu-mcu-eclipse/openocd/releases gnu-mcu-eclipse downloads page]. Download the appropriate file, e.g. " gnu-mcu-eclipse-openocd-0.10.0-12-20190422-2015-win64.zip”. The archive contains a path like “GNU MCU Eclipse/OpenOCD/0.10.0-12-20190422-2015”. Extract the contents of the inner directory (i.e. the subdirectories “bin”, “doc”, “scripts”…) into some directory whose path does not contain any spaces, e.g. “C:\OpenOCD”. You should now have a directory “C:\OpenOCD\bin” or similar. Copy its full path.

[[File:ArmAsmTutorial_PcProperties.png|300px|thumb|right|Opening PC properties]][[File:ArmAsmTutorial_SetEnvVar.png|300px|thumb|right|Setting environment variable]]Set the “Path” environment variable to include this path: Right-Click on “This PC”, then “Properties” → “Advanced System Settings”→ “Environment Variables”. In the lower list (labeled “System variables”), select “Path”. Click “Edit” → “New”, paste the path, and click “OK” multiple times.

Open a ''new'' command window (Windows Key + R, type “cmd” + Return). Type <code>arm-none-eabi-as -version</code>. The output should look similar to this:
<source>
C:\>arm-none-eabi-as -version
GNU assembler (GNU Tools for Arm Embedded Processors 8-2019-q3-update) 2.32.0.20190703
Copyright (C) 2019 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or later.
This program has absolutely no warranty.
This assembler was configured for a target of `arm-none-eabi'.
</source>
Similarly, for <code>openocd -v</code>:
<source>
C:\>openocd -v
GNU MCU Eclipse OpenOCD, 64-bitOpen On-Chip Debugger 0.10.0+dev-00593-g23ad80df4 (2019-04-22-20:25)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
</source>

If an error message appears, the installation isn’t correct.

== Writing assembly applications ==
The full source code of the examples in the following chapters contain be found on [https://github.com/Erlkoenig90/ArmAsmTutorial GitHub]. The name of the corresponding directory is given after each example code below.
=== First rudimentary program ===
After the software setup, you can begin setting up a first project. Create an empty directory for that, e.g. “prog1”.

Inside the project directory, create your first assembly file “prog1.S” (“.S” being the file name extension for assembly files in GNU context) with the following content:
<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

nop @ Do Nothing
b . @ Endless loop
</source>
Example name: “EmptyProgram”

When this file is sent to the assembler, it will translate the instructions into binary machine code, with 2 or 4 bytes per instruction. These bytes are concatenated to form a program image, which is later written into the controller’s flash memory. Therefore, assembly code more or less directly describes flash memory contents.

The lines starting with a dot “.” are assembler directives that control the assembler’s operation. Only some of those directives emit bytes that will end up in flash memory. The @ symbol starts a comment.

The first line lets the assembler use the new “unified” instruction syntax (“UAL” - Unified Assembler Language) instead of the old ARM syntax. The second line declares the used processor Cortex-M3, which the assembler needs to know in order to recognize the instructions available on that processor. The third line instructs the assembler to use the Thumb (T32) instruction set. We can’t start putting instructions in flash memory right away, as the processor expects a certain data structure to reside at the very beginning of the memory. This is what the “.word” and “.space” instructions create. These will be explained later.

The first “real” instruction is “nop”, which will be the first instruction executed after the processor starts. “nop” is short for “No OPeration” - it causes the processor to do nothing and continue with the next instruction. This next instruction is “b .”. “b” is short for “branch” and instructs the processor to jump to a certain “target” location, i.e. execute the instruction at that target next. In assembly language, the dot “.” represents the current location in program memory. Therefore, “b .” instructs the processor to jump to this very instruction, i.e. execute it again and again in an endless loop. Such an endless loop is frequently found at the end of microcontroller programs, as it prevents the processor from executing random data that is located in flash memory after the program.

To translate this assembly code, open a terminal (linux) / command window (Windows). Enter the project directory by typing <code>cd <Path to Project Directory></code>. Call the assembler like this:

<source lang=sh>
arm-none-eabi-as -g prog1.S -o prog1.o
</source>

This instructs the assembler to translate the source file “prog1.S” into an object file “prog1.o”. This is an intermediary file that contains binary machine code, but is not a complete program yet. The “-g”-Option tells the assembler to include debug information, which does not influence the program itself, but makes debugging easier. To turn this object file into a final program, call the linker like this:

<source lang=sh>
arm-none-eabi-ld prog1.o -o prog1.elf -Ttext=0x8000000
</source>

This creates a file “prog1.elf” that contains the whole generated program. The “-Ttext” option instructs the linker to assume 0x8000000 as the start address of the flash memory. The linker might output a warning like this:

<pre>arm-none-eabi-ld: warning: cannot find entry symbol _start; defaulting to 0000000008000000</pre>

This is not relevant for executing the program without an operating system and can be ignored.

=== Flashing the program ===
To download the compiled application to the microcontroller that has been attached via ST-Link, use OpenOCD like so:
<source lang=sh>
openocd -f interface/stlink-v2.cfg -f target/stm32f1x.cfg -c "program prog1.elf verify reset exit"
</source>
Unfortunately, the application does not do anything that can be observed from the outside, except perhaps increase the current consumption.
=== Starting the debugger ===
To check whether the program is actually running, start a debugging session to closely observe the processor’s behavior. First, run OpenOCD such that it acts as a GDB server:
<source lang=sh>
openocd -f interface/stlink-v2.cfg -f target/stm32f1x.cfg
</source>
Then, open a new terminal/command window and start a GDB session:
<source lang=sh>
arm-none-eabi-gdb prog1.elf
</source>
GDB provides its own interactive text-based user interface. First, type this command to let GDB connect to the already running OpenOCD instance:
<source>
target remote :3333
</source>
Then, stop the currently running program:
<source>
monitor reset halt
</source>
If this fails, hold your board’s reset button just before executing the command and repeat until it succeeds. GDB can also download code to flash memory by simply typing:
<source>
load
</source>
Which will overwrite the previously flashed program (which, in this case, is identical anyways). After loading the program, reset the controller again:
<source>
monitor reset halt
</source>
Now, examine the contents of the CPU registers:
<source>
info reg
</source>
The output should look something like
<pre>
r0 0x0 0
r1 0x0 0
r2 0x0 0
r3 0x0 0
r4 0x0 0
r5 0x0 0
r6 0x0 0
r7 0x0 0
r8 0x0 0
r9 0x0 0
r10 0x0 0
r11 0x0 0
r12 0x0 0
sp 0x0 0x0
lr 0x0 0
pc 0x8000000 0x8000000 <_stack+133693440>
xPSR 0x1000000 16777216
msp 0x20000400 0x20000400
psp 0x27e3fa34 0x27e3fa34
primask 0x0 0
basepri 0x0 0
faultmask 0x0 0
control 0x0 0
</pre>

At this point, the processor is ready to start executing your program. The processor is halted just before the first instruction, which is “nop”. You can let the processor execute one single instruction (i.e. the “nop”) by typing
<source>
stepi
</source>
If you type <code>info reg</code> again, you will see that PC is now “0x80000ee”, i.e. the processor is about to execute the next instruction, “b .”. When you do <source>stepi</source> again (repeatedly), nothing more will happen – the controller is stuck in the mentioned endless loop, exactly as intended. You can instruct the processor to run the program continuously, without stopping after each instruction by typing
<source>
continue
</source>
You can interrupt the running program by pressing “Ctrl+C”. Run the commands
<source>
kill
quit
</source>
to exit GDB. You can terminate OpenOCD by pressing “Ctrl+C” in its terminal.
=== Using processor registers ===
The example program hasn’t done anything useful, but any “real” program will need to process some data. On ARM, any data processing is done via the processor registers. The 32bit ARM platforms have 16 processor registers, each of which is 32bit in size. The last three of those (r13-r15) have a special meaning and can only be used with certain restrictions. The first thirteen (r0-r12) can be used freely by the application code for data processing.

All calculations (e.g. addition, multiplication, logical and/or) need to be performed on those processor registers. To process data from memory, it first has to be loaded into a register, then processed, and stored back into memory. This is typical for RISC platforms and is known as a “load-store-architecture”.

As the starting point for any calculation, some specific values need to be put into the registers. The easiest way to do that is:
<source lang=asm>
ldr r0, =123456789
</source>
The number 123456789 will be encoded as part of the program, and the instruction lets the processor copy it into the register “r0”. Any number and any register in the range r0-r13 can be used instead.

The instruction “mov” can be used to copy the contents from one register to another:
<source lang=asm>
mov r1, r0
</source>
This copies r0 to r1. Unlike some other processor architectures, “mov” can not be used to access memory, but only the processor registers.

In ARM, 32bit numbers are called "words" and are most frequently used. 16bit numbers are known as half-words, and 8bit numbers as bytes, as usual.
=== Accessing periphery ===
To write microcontroller programs that interact with the outside world, access to the controller’s periphery modules is required. Interaction with periphery happens mainly through periphery registers (also known as “special function registers”, SFR). Despite their name, they work quite differently from processor registers. Instead of numbers, they have addresses (in the range of 0x40000000-0x50000000) that are not contiguous (i.e. there are gaps), they cannot be directly used for data processing but need to be explicitly read and written before and after any calculations. Not all of them are 32bit; many have only 16bit, and some of those bits may not exist and can’t be accessed. The microcontroller manufacturer’s documentation uses names for these registers, but the assembler doesn’t know these. Therefore, the assembly code needs to use the numerical addresses.

The easiest way to get the microcontroller to do something that produces some visible result is to send a signal via an output pin to turn on an LED. Using a pin to send/receive arbitrary software-defined signals is called “GPIO” (General Purpose Input/Output). First, choose a pin – for example, PA8 (this one is available on all package variants). Connect an LED to this pin and to GND (“active high”). Use a series resistor to limit the current to max. 15mA (the absolute maximum being 25mA), e.g. 100Ω for a 3,3V supply and a standard LED. For higher loads (e.g. high-power LEDs or a relay) use an appropriate transistor.

As with most microcontrollers, the pins are grouped into so-called “ports”, each of which has up to 16 pins. The ports are named by letters of the alphabet, i.e. “GPIOA”, “GPIOB”, “GPIOC” etc. The number of ports and pins varies among the individual microcontroller types. The 16 pins of one port can be read or written in one single step.

==== Clock Configuration ====
Many ARM controllers feature a certain trap: Most periphery modules are disabled by default to save power. The software has to explicitly enable the needed modules. On STM32 controllers, this is done via the “RCC” (Reset and Clock Control) module. Particularly, this module allows the software to disable/enable the clock signal for each periphery module. Because MOSFET-based circuits (virtually all modern ICs) only draw power if a clock signal is applied, turning off the clock of unused modules can reduce the power usage considerably.

This is documented in the aforementioned reference manual in chapter 7. The subchapter 7.3.7 describes the periphery register “RCC_APB2ENR” which allows you to configure the clock signal for some peripheral modules. This register has 32 bits, of which 14 are “reserved”, i.e. can’t be used and should only be written with zeroes. Each of the available 18 bits enables one specific periphery module if set to “1” or disables it if set to “0”. According to the manual, the reset value of this register is 0, so all periphery modules are disabled by default. In order to turn on the GPIOA module to which the desired pin PA8 belongs, the bit “IOPAEN” needs to be set to “1”. This is bit number two in the register. Since registers can only be accessed to as a whole (individual bits can’t be addressed), a 32bit-value where bit two is “1” and all others are kept as “0” needs to be written. This value is 0x00000004.

To write to the register, its address needs to be given in the code. The addresses of the periphery registers are grouped by the periphery modules they belong to - each periphery module (e.g. RCC, GPIOA, GPIOB, USB, …) has its own base address. The addresses of the individual registers are specified as an offset that needs to be added to this base address to obtain the full absolute address of the register. Chapter 7.3.7 specifies the offset address of RCC_APB2ENR as “0x18”. Chapter 3.3 specifies the base addresses of all periphery modules – RCC is given as “0x40021000”. So, the absolute address of RCC_APB2ENR is “0x40021000+ 0x18=0x40021018”.

In short: To enable GPIOA, the value '''0x00000004''' needs to be written to address '''0x40021018'''.

According to the “load-store” principle, ARM processors can’t do this in a single step. Both the value to be written and the address need to reside in processor registers in order to perform the write access. So, what needs to done is:
* Load the value 0x00000004 into a register
* Load the value 0x40021018 into another register
* Store the value from the first register into the memory location specified by the second register.
This last step is performed by the “STR” instruction as follows:
<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

ldr r0, =0x00000004
ldr r1, =0x40021018
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
b .
</source>
The square brackets are required but just serve as a reminder to the programmer that the contents of “r1” is used as an address. After the “str” instruction, the GPIOA periphery is enabled, but doesn’t do anything yet.

==== GPIO Configuration ====
By default, all GPIO pins are configured as “input”, even if there is no software to process the input data. Since inputs are “high-impedance”, i.e. only a very small current can flow into/out of the pin, the risk of (accidental) short-circuits and damage to the microcontroller is minimized. However, this current is too small to light up an LED, so you have to configure the pin PA8 as “output”. The STM32 support multiple output modes, of which the right one for the LED is “General Purpose Output Push-Pull, 2 MHz”.

Access and configuration of GPIO pins is achieved via the registers of the GPIO periphery. The STM32 have multiple identical instances of GPIO modules, which are named GPIOA, GPIOB, … Each of those instances has a distinct base address, which are again described in chapter 3.3 of the reference manual (e.g. “0x40010800” for GPIOA, “0x40010C00” for GPIOB etc.). The registers of the GPIO module are described in chapter 9.2, and there is one instance of each register per GPIO module. To access a specific register of a specific GPIO module, the base address of that module needs to be added to the offset address of the register. For example, “GPIOA_IDR” has address “0x40010800+0x08=0x40010808”, while “GPIOB_ODR” has address “0x40010C00+0x0C= 0x40010C0C”.

Configuration of the individual GPIO pins happens through the “GPIOx_CRL” and “GPIOx_CRH” registers (“x” is a placeholder for the concrete GPIO module) – see chapters 9.2.1 and 9.2.2. Both registers are structured identically, where each pin uses 4 bits, so each of the two registers handles 8 pins in 8x4=32 bits. Pins 0-7 are configured by “GPIOx_CRL” and pins 8-15 by “GPIOx_CRH”. Pin 0 is configured by bits 0-3 of “GPIOx_CRL”, pin 1 by bits 4-7 of “GPIOx_CRL”, pin 8 by bits 0-3 of “GPIOx_CRH” and so on.

The 4 bits per pin are split into two 2-bit fields: “MODE” occupies bits 0-1, and “CNF” bits 2-3. “MODE” selects from input and output modes (with different speeds). In output mode, “CNF” determines whether the output value is configured from software (“General Purpose” mode) or driven by some other periphery module (“Alternate function” mode), and whether two transistors (“Push-pull”) or one (“open-drain”) are used to drive the output. In input mode, “CNF” selects from analog mode (for ADC), floating input and input with pull-up/down resistors (depending on the value in the “GPIOx_ODR” register).

Therefore, to configure pin PA8 into “General Purpose Output Push-Pull, 2 MHz” mode, bits 0-3 of “GPIOA_CRH” need to be set to value “2”. The default value of “4” configures the pin as “input”. To keep the other pins at their “input” configuration, the value “0x44444442” needs to be written to register “GPIOA_CRH”, which has address “0x40010804”:
<source lang=asm>
ldr r0, =0x44444442
ldr r1, =0x40010804
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2
</source>

==== Writing GPIO pins ====
The GPIO pin still outputs the dafult value, which is 0 for “low”. To turn on the LED, the output has to be set to “1” for “high”. This is achieved via the GPIOA_ODR register, which has 16bits, one for each pin (see chapter 9.2.4). To enable the LED, set bit 8 to one:
<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

ldr r0, =0x00000004
ldr r1, =0x40021018
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA

ldr r0, =0x44444442
ldr r1, =0x40010804
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2

ldr r0, =0x100
ldr r1, =0x4001080C
str r0, [r1] @ Set ODR8 in GPIOA_ODR to 1 to set PA8 high

b .
</source>
Example name: “SetPin”

This program enables the GPIOA periphery clock, configures PA8 as output, and sets it to high. If you run it on your microcontroller, you should see the LED turn on – the first program to have a visible effect!

=== Data processing ===
ARM supports many instructions for mathematical operations. For example, addition can be performed as:
<source lang=asm>
ldr r0, =222
ldr r1, =111
add r2, r0, r1
</source>
This will first load the value 222 into register r0, load 111 into r1, and finally add r0 and r1 and store the result (i.e. 333) in r2. The operand for the result is (almost) always put on the left, while the input operand(s) follow on the right.

You can also overwrite an input register with the result:
<source lang=asm>
add r0, r0, r1
</source>
This will write the result to r0, overwriting the previous value. This is commonly shortened to
<source lang=asm>
add r0, r1
</source>
The output operand can be omitted, and the first input (here: r0) will be overwritten. This applies to most data processing instructions. Other frequently used data processing instructions that are used in a similar fashion are:
* '''sub''' for subtraction
* '''mul''' for multiplication
* '''and''' for bitwise and
* '''orr''' for bitwise or
* '''eor''' for bitwise exclusive or (“xor”)
* '''lsl''' for logical left shift
* '''lsr''' for logical right shift

Most of these instructions can not only take registers as input, but also immediate arguments. Such an argument is encoded directly into the instruction without needing to put it into a register first. Immediate arguments need to be prefixed by a hash sign #, and can be decimal, hexadecimal or binary. For example,
<source lang=asm>
add r0, r0, #23
</source>
adds 23 to the register r0 and stores the result in r0. This can again be shortened to
<source lang=asm>
add r0, #23
</source>

Such immediate arguments can not be arbitrarily large, because they need to fit inside the instruction, which is 16 or 32 bit in size and also needs some room for the instruction and register numbers as well. So, if you want to add a large number, you have to use “ldr” first as shown to load it into a register.

Try out the above examples and use GDB to examine their behavior. Use GDB’s “info reg” command to display the register contents. Don't forget to execute both the “arm-none-eabi-as” and “arm-none-eabi-ld” commands to translate the program.

=== Reading periphery registers ===
The last example works, but has a flaw: Even though only a few bits per register need to be modified, the code overwrites all the bits in the register at once. The bits that should not be modified are just overwritten with their respective default value. If some of those bits had been changed before – for example to enable some other periphery module – these changes would be lost. Keeping track of the state of the register throughout the program is hardly practical. Since ARM does not permit modifying individual bits, the solution is to read the whole register, modify the bits as needed, and write the result back. This is called a “read-modify-write” cycle.

Reading registers is done via the “ldr” instruction. As with “str”, the address needs to be written into a processor register beforehand, and the instruction stores the read data into a processor register as well. Starting the with the “RCC_APB2ENR” register, you can read it via:
<source lang=asm>
ldr r1, =0x40021018
ldr r0, [r1]
</source>
Even though the two “ldr” instruction look similar, they work differently – the first one loads a fixed value into a register (r1), while the second loads data from the periphery register into r1.

The loaded value should then be modified by setting bit two to “1”. This can be done with the “orr” instruction:
<source lang=asm>
orr r0, r0, #4
</source>
After that, we can store r0 as before.

With the GPIOA_CRH register, it’s slightly more complicated: The bits 0, 2 and 3 need to be cleared, while bit 1 needs to be set to 1. The other bits (4-31) need to keep their value. To clear the bits, use the “and” instruction after loading the current periphery register value:

<source lang=asm>
ldr r1, =0x40010804
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #2
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2
</source>

For the “GPIOx_ODR” registers, such tricks are not needed, as there is a special “GPIOx_BSRR” register which simplifies writing individual bits: This register can not be read, and writing zeroes to any bit has no effect on the GPIO state. However, if a 1 is written to any of the bits 0-15, the corresponding GPIO pin is set to high (i.e. the corresponding bit in ODR set to 1). If any of the bits 16-31 is written to 1, the corresponding pin is set to low. So, the pin can be set to 1 like this:

<source lang=asm>
ldr r1, =0x40010810
ldr r0, =0x100
str r0, [r1] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high
</source>

So, the modified program is:
<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

ldr r1, =0x40021018
ldr r0, [r1]
orr r0, r0, #4
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA

ldr r1, =0x40010804
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #2
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2

ldr r1, =0x40010810
ldr r0, =0x100
str r0, [r1] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

b .
</source>
Example name: “SetPin2”
=== Jump instructions ===
For a traditional “hello world” experience, the LED should not only light up, but blink, i.e. turn on and off repeatedly. Setting pin PA8 to low level can be achieved by writing a 1 to bit 24 in the “GPIO_BSRR” register:

<source lang=asm>
ldr r1, =0x40010810
ldr r0, =0x1000000
str r0, [r1]
</source>

By pasting the this behind the instructions for turning on the LED, it will be turned on and off again. To get the LED to blink, those two blocks need to be repeated endlessly, i.e. at the end of the code there needs to be an instruction for jumping back to the beginning.

A simple endless loop was already explained: The “b .” instruction, which just executes itself repeatedly. To have it jump somewhere else, the dot needs to be substituted for the desired target address, for example:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

ldr r1, =0x40021018
ldr r0, [r1]
orr r0, r0, #4
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA

ldr r1, =0x40010804
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #2
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2

ldr r1, =0x40010810
ldr r0, =0x100
str r0, [r1] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r1, =0x40010810
ldr r0, =0x1000000
str r0, [r1] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

b 0x8000104
</source>
Example name: “Blink”

The address specified is an absolute address, which is the address of the “ldr” instruction at the beginning of the block for setting the pin to high. Actually, the branch instruction “b” is not capable of jumping directly to such an absolute address - again, because a 32 bit wide address can't be encoded in a 16/32 bit wide instruction. Instead, the assembler calculates the distance of the jump target and the location of the “b” instruction, and stores it into the instruction. When jumping backwards, this distance is negative.

When executing program code, the processor always stores the address of the currently executed instruction plus four in the r15 register, which is therefore also known as PC, the program counter. When encountering a “b” instruction, the processor adds the contained distance value to the PC value to calculate the absolute address of the jump target before jumping there.

This means that “b” performs a relative jump, and even if the whole machine code section were moved somewhere else in memory, the code would still work. However, the assembly language syntax does not really represent this, as the assembler expects absolute addresses which it then transforms into relative ones.

Specifying the target address directly as shown is very impractical, as it has to be calculated manually, and if the section of code is moved or modified, the address needs to be changed. To rectify this, the assembler supports labels: You can assign a name to a certain code location, and use this name to refer to the code location instead of specifying the address as a number. A label is defined by writing its name followed by a colon:

<source lang=asm>
BlinkLoop:

ldr r1, =0x40010810
ldr r0, =0x100
str r0, [r1] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r1, =0x40010810
ldr r0, =0x1000000
str r0, [r1] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

b BlinkLoop
</source>
Example name: “Blink2”

This is purely a feature of the assembler – the generated machine code will be identical to the previous example. In “b BlinkLoop”, the assembler substitutes the label for the address it represents to calculate the relative jump distance. The assembler actually provides no direct way of directly specifying the relative offset that will be encoded in the instruction, but it can be done like this:

<source lang=asm>
b (.+4+42*2)
</source>

The resulting instruction will contain “42” as the jump offset. As suggested by the syntax, the processor multiples this number by 2 (since instructions can only reside at even memory addresses, it would waste one bit of memory to specify the number directly) and adds to it the address of the “b” instruction plus 4. The assembly syntax is designed to represent the end result of the operation, so the assembler reverses the peculiar pre-calculations of the processor. If you want to do this calculation yourself, you have to again undo the assembler’s own calculation with the expression shown above. There is usually no reason to do that, though.

=== Counting Loops ===
The above example for a blinking LED does not really work yet – the LED blinks so fast the human eye can’t see it. The LED will just appear slightly dim. To achieve a proper blinking frequency, the code needs to be slowed down. The easiest way for that is to have the processor execute a large number of “dummy” instructions between setting the pin high and low. Simply placing many “nop” instructions isn’t possible though, as there is simply not enough program memory to store all of them. The solution is a loop that executes the same instructions a specific number of times (as opposed to the endless loops from the examples above). To do that, the processor has to count the number of loop iterations. It is actually easier to count ''down'' than up, so start by loading the desired number of iterations into a register and begin the loop by subtracting “1”:

<source lang=asm>
ldr r2, =1000000
subs r2, #1
</source>

Now, the processor should make a decision: If the register has reached zero, terminate the loop; else, continue by again subtracting “1”. The ARM math instructions can automatically perform some tests on the result to check whether it is positive/negative or zero and whether an overflow occurred. To enable those checks, append an “s” to the instruction name – hence, “subs” instead of “sub”. The result of these checks is automatically stored in the “Application Program Status Register” (APSR) – the contained bits N, Z, C, V indicate whether the result was negative, zero, set the carry bit or caused an overflow. This register is usually not accessed directly. Instead, use the conditional variant of the “b” instruction, where two letters are appended to indicate the desired condition. The jump is only performed if the condition is met; otherwise, the instruction does nothing. The available condition codes are described in the chapter “Condition Codes” of this tutorial. The conditions are formulated in terms of the mentioned bits of the APSR. For example, the “bne” instruction only performs a jump if the zero (Z) flag is ''not'' set, i.e. when the result of the last math instruction (with an “s” appended) was ''not'' zero. The “beq” instruction is the opposite of that – it only performs a jump if the result ''was'' zero.

So, to perform the jump back to the beginning of the loop, add a label before the “subs” instruction, and put a “bne” instruction after the “subs” that jumps to this label if the counter has not reached zero yet:
<source lang=asm>
ldr r2, =1000000
delay1:
subs r2, #1
bne delay1 @ Iterate delay loop
</source>

The actual loop consists only of the two instructions “subs” and “bne”. By placing two of those loops (with two different labels!) in between the blocks that turn the pins on and off, the blink frequency is lowered sufficiently such that it becomes visible:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

ldr r1, =0x40021018
ldr r0, [r1]
orr r0, r0, #4
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA

ldr r1, =0x40010804
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #2
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2

BlinkLoop:
ldr r1, =0x40010810
ldr r0, =0x100
str r0, [r1] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r2, =1000000
delay1:
subs r2, #1
bne delay1 @ Iterate delay loop

ldr r1, =0x40010810
ldr r0, =0x1000000
str r0, [r1] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

ldr r2, =1000000
delay2:
subs r2, #1
bne delay2 @ Iterate delay loop

b BlinkLoop
</source>
Example name: “BlinkDelay”

You might notice that the registers r0-r2 are loaded with the same values over and over again. To make the code both shorter and faster, take advantage of the available processor registers, and load the values that don’t change ''before'' the loop. Then, just use them inside the loop:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

ldr r1, =0x40021018
ldr r0, [r1]
orr r0, r0, #4
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA

ldr r1, =0x40010804
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #2
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2

ldr r0, =0x40010810 @ Load address of GPIOA_BSRR
ldr r1, =0x100 @ Register value to set pin to high
ldr r2, =0x1000000 @ Register value to set pin to low
ldr r3, =1000000 @ Iterations for delay loop

BlinkLoop:
str r1, [r0] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

mov r4, r3
delay1:
subs r4, #1
bne delay1 @ Iterate delay loop

str r2, [r0] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

mov r4, r3
delay2:
subs r4, #1
bne delay2 @ Iterate delay loop

b BlinkLoop
</source>
Example name: “BlinkDelay2”

=== Using RAM ===
Until now, all data in the example codes was stored in periphery or processor registers. In all but the most simple programs, larger amounts of data have to be processed for which the thirteen general-purpose processor registers aren’t enough. For this, the microcontroller features a block of SRAM that stores 20 KiB of data. Accessing data in RAM works similar to accessing periphery registers – load the address in a processor register and use “ldr” and “str” to read and write the data. After reset, the RAM contains just random ones and zeroes, so before the first read access, some value has to be stored.

As the programmer decides what data to place where, they have to keep track which address in memory contains what piece of data. You can use the assembler to help keeping track by declaring what kind of memory blocks you need and giving them names. To do this, you must first tell the assembler that the next directives refer to data instead of instructions with the “.data” directive. Then, use the “.space” directive for each block of memory you need. To assign names to the blocks, place a label definition (using a colon) right ''before'' that. After the definitions, put a “.text” directive to make sure the instructions after that will properly go to program memory (flash):

<source lang=asm>
.data
var1:
.space 4 @ Reserve 4 bytes for memory block “var1”
var2:
.space 1 @ Reserve 1 byte for memory block “var2”

.text
@ Instructions go here...
</source>

Here, a data block of 4 bytes is reserved and named “var1”. Another block of 1 byte is named “var2”. Note that just inserting these lines will not modify the assembler output – these are just instructions to the assembler itself. To access these memory blocks, you can use “var1” and “var2” just like literal addresses. Load them into registers and use these with “ldr” and “str” like this:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word 0x20000400
.word 0x080000ed
.space 0xe4

.data
var1:
.space 4 @ Reserve 4 bytes for memory block “var1”
var2:
.space 1 @ Reserve 1 byte for memory block “var2”

.text

ldr r0, =var1 @ Get address of var1
ldr r1, =0x12345678
str r1, [r0] @ Store 0x12345678 into memory block “var1”

ldr r1, [r0] @ Read memory block “var1”
and r1, #0xFF @ Set bits 8..31 to zero
ldr r0, =var2 @ Get address of var2
strb r1, [r0] @ Store a single byte into var2

b .
</source>
Example name: “RAMVariables”

Note the use of “strb” - it works similar to “str”, but only stores a single byte. Since the processor register r1 is of course 32bit in size, only the lower 8 bits are stored, and the rest is ignored.

There is still something missing – nowhere in the code is there any address of the RAM. To tell the linker where the RAM is located, pass the option <code>-Tdata=0x20000000</code> to the <code>arm-none-eabi-ld</code> call to tell the linker that this is the address of the first byte of RAM.

If you run this program via GDB, you can use the commands <code>x/1xw &var1</code> and <code>x/1xb &var2</code> to read the data stored in memory. After this quick introduction a more abstract overview is indicated.

== Memory Management ==
If there is one thing that sets higher and lower level programming languages apart, it’s probably memory management. Assembly programmers have to think about memory, addresses, layout of program and data structures all the time. Assembler and linker provide some help which needs to be utilized effectively. Therefore, this chapter will explain some more fundamentals of the ARM architecture and how the toolchain works.

=== Address space ===
In the examples so far, addresses where used for periphery register accesses and jump instructions without really explaining what they mean, so it’s time to catch up with that. To access periphery registers and memory locations in any memory type (RAM, Flash, EEPROM…), an address is required, which identifies the desired location. On most platforms, addresses are simply unsigned integers. The set of all possible addresses that can be accessed in a uniform way is called an “address space”. Some platforms such as AVR have multiple address spaces (for Flash, EEPROM, and RAM+periphery) where each memory needs to be accessed in a distinct way and the programmer needs to know which address space an address belongs to – e.g. all three memory types have a memory location with address 123.

However, the ARM architecture uses only a single large address space where addresses are 32bit unsigned integers in the range of 0-4294967295. Each address refers to one byte of 8 bits. The address space is divided into several smaller ranges, each of which refers to a specific type of memory. For the STM32F103, this is documented in the datasheet in chapter 4. All addresses in all memory types are accessed in the same way – directly via the “ldr” and “str” instructions, or by executing code from a certain location, which can be achieved by jumping to the respective address with the “b” instruction. This also makes it possible to execute from RAM – simply perform a jump to an address that refers to some code located in RAM. Note that there are large gaps between the individual ranges in address space; attempting to access those usually leads to a crash.

While the addresses of periphery are fixed and defined by the manufacturer, the layout of program code and data in memory can be set by the programmer rather freely. Up until now, the example programs defined the flash memory contents in a linear fashion by listing the instructions on the order they should appear in flash memory. However, when translating multiple assembly source files into one program, the order in which the contents from those files appears in the final program isn’t defined a priori. Also, even though in the last example the memory blocks for RAM were defined ''before'' the code, the code actually comes first in address space. What makes all this work is the Linker.

=== The Linker ===
Usually the last step in translating source code into a usable program, the linker is an often overlooked, sometimes misunderstood but important and useful tool, if applied correctly. Many introductions into programming forego explaining its workings in detail, but as any trade, embedded development requires mastery of the tools! A good understanding of the linker can save time solving strange errors and allow you to implement some less common use cases, such as utilizing multiple RAM blocks present in some microcontrollers, executing code from RAM or defining complex memory layouts as sometimes required by RTOSes.

[[File:ArmAsmTutorial_Linking.svg|300px|thumb|right|Translation of native applications using assembler, compiler and linker]]You have already used a linker – the command <code>arm-none-eabi-ld</code> calls the GNU linker that is shipped with the GNU toolchain. Until now, only one assembly source files was translated for each program. To translate a larger program that consists of three assembly files “file1.S”, “file2.S” and “file3.s”, the assembler would be called three times to produce three object code files “file1.o”, “file2.o” and “file3.o”. The linker would then be called to combine all three into a single output file.

When translating any of these assembly files, the assembler does not know of the existence of the other files. Therefore, it can’t know whether the contents of any other file will end up in flash memory before the currently processed file, and also can’t know the final location in flash memory of the machine code it is emitting and placing in the object file (ending .o). This means that the object file does not contain any absolute addresses (except for those of periphery registers, as these were specified explicitly). For example, when loading the address of the RAM data blocks (“ldr r0, =var1”) the assembler doesn’t know the address, only the linker does. Therefore, the assembler puts a placeholder in the object file that will be overwritten by the linker. A jump (“b” instruction) to a label defined in another assembly file works similarly; the assembler uses a placeholder for the address. For the jump instructions we used inside the same file (e.g. “b BlinkLoop”), a placeholder is not necessary, as the assembler can calculate the distance of the label and the instruction and generate the relative jump itself. However, if the target resides within a different section (see below), this isn’t possible, and a placeholder becomes necessary. As the contents of object files has no fixed address and can be moved around by the linker, these files are called relocatable.

On Unix Systems (including Linux), the Executable and Linkable Format (ELF) is used for both object files and executable program files. This format is also used by ARM, and the GNU ARM toolchain. Because it was originally intended to be used with operating systems, some of its concepts don’t perfectly map the embedded use case. The object (.o) files created by the assembler and linker, and also the final program (usually no ending, but in embedded contexts and also in above example commands, .elf is used) are all in ELF format. The specification of ELF for ARM can be found [https://developer.arm.com/architectures/system-architectures/software-standards/abi here], and the generic specification for ELF on which the ARM ELF variant is based can be found [http://www.sco.com/developers/gabi/2003-12-17/contents.html here].

ELF files are structured into sections. Each section may contain code, data, debug information (used by GDB) and other things. In an object file, the sections have no fixed address. In the final program file, they have one. Sections also have various attributes that indicate whether its contents is executable code or data, is read-only and whether memory should be allocated for it. The linker combines and reorders the sections from the object files (“input sections”) and places them into sections in the final program file (“output sections”) while assigning them absolute addresses.

Another important aspect are symbols. A symbol defines a name for an address. The address of a symbol may be defined as an absolute number (e.g. 0x08000130) or as an offset relative to the beginning of a section (e.g. “start address of section .text plus 0x130”). Labels defined in assembly source code define symbols in the resulting object file. For example, the “var1” label defined in the last example results in a symbol “var1” in the “prog1.o” file whose address is set to be equal to the beginning of “.data”. The symbol “var” is defined similarly, but with an offset of 4. After the linking process, the “prog1.elf” file contains a “.data” section with absolute address 0x20000000, and so the “var1” and “var2” symbols get absolute addresses as well.

As mentioned, the assembler puts placeholders in the object files when it doesn’t know the address of something. In ELF files, there placeholders are called “relocation entries” and they reference symbols by name. When the linker sees such a relocation entry in one of its input files, it searches for a symbol in the input files with a matching name and fills in its address. If no symbol with that name was found, it emits this dreaded error:

<pre>(.text+0x132): undefined reference to `Foo'</pre>

Google finds almost a million results for that message, but knowing how the linker operates makes it easy to understand and solve – since the symbol was not found in any object file, make sure it is spelled correctly and that the object file that contains it is actually fed to the linker.

=== Linker Scripts ===
A linker script is a text file written in a linker-specific language that controls how the linker maps input sections to output sections. The example project hasn’t explicitly specified one yet, which lets the linker use a built-in default one. This has worked so far, but results in a slightly mixed up program file (unsuitable symbols) and has some other disadvantages. Therefore, it’s time to do things properly and write a linker script. Linker scripts aren’t usually created on a per-project basis, but usually provided by the microcontroller manufacturer to fit a certain controller’s memory layout. To learn how they work, a quick introduction into writing one will follow. The full documentation can be found [https://sourceware.org/binutils/docs/ld/Scripts.html here].

It’s customary to name the linker script after the controller they are intended for, so create a text file “stm32f103rb.ld” or “stm32f103c8.ld” with the following contents:

<source>
MEMORY {
FLASH : ORIGIN = 0x8000000, LENGTH = 128K
SRAM : ORIGIN = 0x20000000, LENGTH = 20K
}

SECTIONS {
.text : {
*(.text)
} >FLASH

.data (NOLOAD) : {
*(.data)
} >SRAM
}
</source>
Example name: “LinkerScriptSimple”

This is this minimum viable linker script for a microcontroller. If you are using a STM32F103C8, replace the 128K by 64K. The lines inside the “MEMORY” block define the available memory regions on your microcontroller by specifying their start address and size within the address space. The names “FLASH” and “SRAM” can be chosen arbitrarily, as they have no special meaning. This memory definition has no meaning outside of the linker script, as it is just an internal helper for writing the script; it can even be left out and replaced by some manual address calculations.

The interesting part happens inside the “SECTIONS” command. Each sub-entry defines an output section that will end up in the final program file. These can be named arbitrarily, but the names “.text” and “.data” for executable code and data storage respectively are usually used. The asterisk expressions “*(.text)” and “(*.data)” tell the linker to put the contents of the input sections “.text” and “.data” at that place in the output section. In this case, the names for the input sections and output sections are identical. The input section names “.data”, “.text” (and some more) are used by the assembler and C and C++ compilers by default, so even though they can be changed, it’s best to keep them. You can however name the output sections arbitrarily, for example:

<source>
SECTIONS {
.FlashText : {
*(.text)
} >FLASH

.RamData (NOLOAD) : {
*(.data)
} >SRAM
}
</source>

The commands “>FLASH” and “>SRAM” tell the linker to calculate the address of the output sections according to the respective memory declaration above: The first output section with a “>FLASH” command will end up at address 0x8000000, the next with “>FLASH” right after that section and so on. The “>SRAM” works the same way with the start address “0x20000000”. The “NOLOAD” attribute does not change the linker’s behavior, but marks the corresponding output section as “not-loadable”, such that OpenOCD and GDB will not attempt to write it into RAM – the program has to take care of initializing any RAM data anyways when running stand-alone.

To specify the filename of the linker script, use the “-T” option:
<source lang=sh>
arm-none-eabi-ld prog1.o -o prog1.elf -T stm32f103rb.ld
</source>
The <code>-Tdata</code> and <code>-Ttext</code> aren’t needed anymore, as the addresses are now defined in the linker script.

Since the linker script defines the sizes of the memory regions, the linker can now warn you when your program consumes too much memory (either flash or RAM):
<pre>arm-none-eabi-ld: prog1.elf section `.text' will not fit in region `FLASH'
arm-none-eabi-ld: region `FLASH' overflowed by 69244 bytes</pre>

==== Reserving memory blocks ====
Using the processor’s stack will be explained later, but you can already use the linker script to assign a memory block for it. It’s best to allocate memory for the stack at the ''beginning'' of SRAM, so put this before the “*(.data)” command:

<source>. = . + 0x400;</source>

Inside a linker script, the dot “.” refers to the current address in the output file; therefore, this command increments the address by 0x400, leaving an “empty” block of that size. The “.data” input section will be located after that, at address 0x20000400.

==== Defining symbols in linker scripts ====

As mentioned before, the controller requires a certain data structure called the “vector table” to reside at the very beginning of flash memory. It is defined in the assembler source file:

<source lang=asm>
.word 0x20000400
.word 0x080000ed
.space 0xe4
</source>

The “.word” directive tells the assembler to output the given 32bit-number. Just like processor instructions, these numbers are put into the current section (.text by default, .data if specified) and therefore end up in flash memory. The first 32bit-number, which occupies the first 4 bytes in flash memory, is the initial value of the stack pointer which will be explained later. This number should be equal to the address of the first byte ''after'' the memory block that was reserved for the stack. The reserved block starts at address 0x20000000 and has size 0x400, so the correct number is 0x20000400. However, if the size of the reserved block was modified in the linker script, the above assembly line needs to be adjusted as well. To avoid any inconsistencies, and to be able to manage everything related to the memory-layout centrally in the linker script, it is desirable to replace the number in the assembly source file with a symbol expression. To do this, define a symbol in the linker script:

<source>
.data (NOLOAD) : {
. = . + 0x400;
_StackEnd = .;
*(.data)
} >SRAM
</source>
Example name: “LinkerScriptSymbols”

This will define a symbol “_StackEnd” to have the value of “.”, which is the current address, which at this point is 0x20000400. In the assembly source file, you can now replace the number with the symbol:

<source lang=asm>
.word _StackEnd
</source>

The assembler will put a placeholder in the object file, which the linker will overwrite with the value of 0x20000400. This modification will not change the output file, but avoids putting absolute addresses in source files. The name “_StackEnd” was chosen arbitrarily; since names that start with an underscore and a capital letter may not be used in C and C++ programs, there is no possibility of conflict if any C/C++ source is added later. Typically, all symbols that are part of the runtime environment and should be “invisible” to C/C++ code are named this way. The same rule applies to names starting with two underscores.

The second entry of the vector table is the address of the very first instruction to be executed after reset. Currently the address is hard-coded as the first address after the vector table. If you wanted to insert some other code before this first instruction, this number would have to be changed. This is obviously impractical, and therefore the number should be replaced by a label as well. Since the code executed at reset is commonly known as the “reset handler”, define it like that:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.word _StackEnd
.word Reset_Handler
.space 0xe4

.type Reset_Handler, %function
Reset_Handler:

@ Put code here
</source>

The “.type” directive tells the assembler that the label refers to executable code. The exact meaning of this will be covered later. Leave the “.space” directive alone for now.

==== Absolute section placement ====
The vector table needs to be at the beginning of flash memory, and the examples have relied on the assembler putting the first things from the source file into flash memory first. This stops working if you use multiple source files. You can use the linker script to make sure the vector table is always at the beginning of flash memory. To do that, you first have to separate the vector table from the rest of the code so that the linker can handle it specially. This is done by placing the vector table in its own section:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.section .VectorTable, "a"
.word _StackEnd
.word Reset_Handler
.space 0xe4

.text
.type Reset_Handler, %function
Reset_Handler:
</source>
Example name: “LinkerScriptAbsolutePlacement”

The “.section” directive instructs the assembler to put the following data into the custom section “.VectorTable”. The “a” flag marks this section as allocable, which is required to have the linker allocate memory for it. To place the vector table at the beginning of flash memory, define a new output section in the linker script:

<source>
MEMORY {
FLASH : ORIGIN = 0x8000000, LENGTH = 128K
SRAM : ORIGIN = 0x20000000, LENGTH = 20K
}

SECTIONS {
.VectorTable : {
*(.VectorTable)
} >FLASH

.text : {
*(.text)
} >FLASH

.data (NOLOAD) : {
. = . + 0x400;
_StackEnd = .;
*(.data)
} >SRAM
}
</source>

This puts the .VectorTable input section into the equally-named output section. It is also possible to put it into .text alongside the code:

<source>
MEMORY {
FLASH : ORIGIN = 0x8000000, LENGTH = 128K
SRAM : ORIGIN = 0x20000000, LENGTH = 20K
}

SECTIONS {
.text : {
*(.VectorTable)
*(.text)
} >FLASH

.data (NOLOAD) : {
. = . + 0x400;
_StackEnd = .;
*(.data)
} >SRAM
}
</source>

Even though both variants produce the same flash image, the first one is slightly nicer to work with in GDB. The modified LED-blinker application now looks like:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.section .VectorTable, "a"
.word _StackEnd
.word Reset_Handler
.space 0xe4

.text
.type Reset_Handler, %function
Reset_Handler:

ldr r1, =0x40021018
ldr r0, [r1]
orr r0, r0, #4
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA

ldr r1, =0x40010804
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #2
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2

ldr r0, =0x40010810 @ Load address of GPIOA_BSRR
ldr r1, =0x100 @ Register value to set pin to high
ldr r2, =0x1000000 @ Register value to set pin to low
ldr r3, =1000000 @ Iterations for delay loop

BlinkLoop:
str r1, [r0] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

mov r4, r3
delay1:
subs r4, #1
bne delay1 @ Iterate delay loop

str r2, [r0] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

mov r4, r3
delay2:
subs r4, #1
bne delay2 @ Iterate delay loop

b BlinkLoop
</source>

=== Program Structure ===
Because the vector table is usually the same for all projects, it is handy to move it into a separate file, for example called “vectortable.S”:
<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.section .VectorTable, "a"
.word _StackEnd
.word Reset_Handler
.space 0xe4
</source>

Assemble and link this source code with two assembler commands:
<source lang=sh>
arm-none-eabi-as -g prog1.S -o prog1.o
arm-none-eabi-as -g vectortable.S -o vectortable.o
arm-none-eabi-ld prog1.o vectortable.o -o prog1.elf -T stm32f103rb.ld
</source>

This will result in the dreaded “undefined reference” error. To alleviate this, use the “.global” directive in the main source file “prog1.S”:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
@ Code here ...
</source>

This will tell the assembler to make the symbol “Reset_Handler” visible globally, such that it can be used from other files. By default, the assembler creates a ''local'' symbol for each label, which can’t be used from other source files (same as ''static'' in C). The symbol is still there in the final program file, though - it can be used for debugging purposes.

== More assembly techniques ==
After having set up the project for using the linker properly, some more aspects of assembly programming will be introduced.

=== Instruction set state ===
As mentioned before, ARM application processors support both the T32 and A32/A64 “ARM” instruction sets, and are capable of dynamically switching between them. This can be used to encode time-critical program parts in the faster A32/64 instruction set, and less critical parts in the T32 “thumb” instruction set to save memory. Actually, reducing program size may improve performance too, because the cache memories may become more effective.

Even though the Cortex-M microcontrollers based on the ARMv7-M architecture do not support the A32/A64 instruction sets, some of the switching-logic is still there, requiring the program code to work accordingly. The switch between the instruction sets happens when jumping with the “bx” “Branch and Exchange” and “blx” “Branch with Link and Exchange” instructions. Since all instructions are of size 2 or 4, and code may only be stored at even addresses, the lowest bit of the address of any instruction is always zero. When performing a jump with “bx” or “blx”, the lowest bit of the target address is used to indicate the instruction set of the jump target: If the bit is “1”, the processor expects the code to be T32, else A32.

Another specialty of the “bx” and “blx” instructions is that they take the jump target address from a register instead as encoding it in the instruction directly. This called an indirect jump. An example of such a jump is:

<source lang=asm>
ldr r0, =SomeLabel
bx r0
</source>

Such indirect jumps are necessary if the difference of the jump target address and the jump instruction is too large to be encoded in the instruction itself for a relative jump. Also, sometimes you want to jump to an address that has been passed from another part of the program, which e.g. happens in C/C++ code when using function pointers or virtual functions.

In these cases, you need to make sure that the lowest bit of the address passed to “bx/blx” via a register has the lowest bit set, to indicate that the target code is T32. Otherwise, the code will crash. This can be achieved by telling the assembler that the target label refers to code (and not data) via the already mentioned “.type” directive:

<source lang=asm>
.type SomeLabel, %function
SomeLabel:
@ Some code...
</source>

That way, when you refer to the label to load its address into a register, the lowest bit will be set. Actually, using “.type” for all code labels is a good idea, even though it does not matter if you only refer to a label via the “b” instruction (including the conditional variant) which does not encode the lowest bit and does not attempt to perform an instruction set switch.

As was already shown, there is another case where the lowest bit matters: when specifying the address of the reset handler (and later, exception handler functions) in the vector table, the bit must be set, so the “.type” directive is necessary here too:

<source lang=asm>
.type Reset_Handler, %function
</source>

If you were writing code for a Cortex-A processor, you would use “.arm” instead of “.thumb” to have your code (or performance critical parts of it) encoded as A32. The “.type” directive would be used as well, and the assembler would clear the lowest bit in the address to ensure the code is executed as A32. For example:

<source lang=asm>
.cpu cortex-a8
.syntax unified

@ Small but slower code here
.thumb

.type Block1, %function
Block1:
ldr r0, =Block2
bx r0

@ Larger but faster code here
.arm

.type Block2, %function
Block2:
@ ...
</source>

The directive “.code 32” has the same meaning as “.arm”, and “.code 16” the same as “.thumb” (although the name is slightly misleading, as T32 instructions can be 32 bit as well). There is also “.type Label, %object” to declare some label refers to data in flash or RAM; this is optional, but helps in working with analysis tools (see below).

=== Constants ===
The previous examples contain a lot of numbers (esp. addresses), the meaning of which is not obvious to the reader - so called “magic numbers”. As code is typically read many times more than written/modified, readability is important, even for assembly code. Therefore, it is common practice to define constants that assign names to numbers such as addresses, and use names instead of the number directly.

The assembler actually does not provide any dedicated mechanism for defining constants. Instead, symbols as introduced before are used. You can define a symbol in any of the following ways:
<source lang=asm>
RCC_APB2ENR = 0x40021018
.set GPIOA_CRH, 0x40010804
.equ GPIOA_ODR, 0x4001080C
</source>

and then use it in place of the number:

<source lang=asm>
ldr r1, =RCC_APB2ENR
</source>

Replacing (almost) all numbers in the source code for the LED blinker by constants yields a source code like this:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

RCC_APB2ENR = 0x40021018
RCC_APB2ENR_IOPAEN = 4
GPIOA_CRH = 0x40010804

GPIOA_BSRR = 0x40010810
GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000

GPIOx_CRx_GP_PP_10MHz = 1
GPIOx_CRx_GP_PP_2MHz = 2
GPIOx_CRx_GP_PP_50MHz = 3

GPIOx_CRx_GP_OD_10MHz = 1|4
GPIOx_CRx_GP_OD_2MHz = 2|4
GPIOx_CRx_GP_OD_50MHz = 3|4

GPIOx_CRx_AF_PP_10MHz = 1|8
GPIOx_CRx_AF_PP_2MHz = 2|8
GPIOx_CRx_AF_PP_50MHz = 3|8

GPIOx_CRx_AF_OD_10MHz = 1|4|8
GPIOx_CRx_AF_OD_2MHz = 2|4|8
GPIOx_CRx_AF_OD_50MHz = 3|4|8

GPIOx_CRx_IN_ANLG = 0
GPIOx_CRx_IN_FLOAT = 4
GPIOx_CRx_IN_PULL = 8

DelayLoopIterations = 1000000

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:

ldr r1, =RCC_APB2ENR
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA

ldr r1, =GPIOA_CRH
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2

ldr r0, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r1, =GPIOx_BSRR_BS8 @ Register value to set pin to high
ldr r2, =GPIOx_BSRR_BR8 @ Register value to set pin to low
ldr r3, =DelayLoopIterations @ Iterations for delay loop

BlinkLoop:
str r1, [r0] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

mov r4, r3
delay1:
subs r4, #1
bne delay1 @ Iterate delay loop

str r2, [r0] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

mov r4, r3
delay2:
subs r4, #1
bne delay2 @ Iterate delay loop

b BlinkLoop
</source>
Example name: “BlinkConstants”

This is much more readable than before. In fact, you could even leave out the comments, as the code becomes more self-documenting. The addresses of periphery registers are defined individually, but the bits for the GPIO registers are the same for each GPIO module, so the names include an “x” to denote that they apply to all GPIO modules.

The “CRL”/“CRH” registers get a special treatment. Since the individual bits have little direct meaning, it would be pointless to name them. Instead, 15 symbols are defined to denote the 15 possible modes of operation per pin (combinations of input/output, open-drain vs. push-pull, analog vs. digital, floating vs. pull-resistors, and output driver slew rate). Each of the 15 symbols has a 4 bit value that needs to be written into the appropriate 4 bits of the register. To configure e.g. PA10 as General Purpose Open-Drain with 10 MHz slew rate:

<source lang=asm>
ldr r1, =GPIOA_CRH
ldr r0, [r1]
and r0, #0xfffff0ff
orr r0, #(GPIOx_CRx_GP_OD_10MHz<<8)
str r0, [r1]
</source>

C-like arithmetic operators can be used in constant expressions, like + - * / and bitwise operators like | (or), & (and), << (left shift) and >> (right shift). Note that these calculations are always done by the assembler. In the example, or | is used to combine bit values.

Since these constants are actually symbols, they can collide with assembler labels, so you must not define a symbol with the same name as any label.

A different kind of constants are register aliases. Using the “.req” directive, you can define a name for a processor register:

<source lang=asm>
MyData .req r7
ldr MyData, =123
add MyData, 3
</source>

This can be useful for large assembly blocks where the meaning of register data is not obvious. It also allows you to re-assign registers without having to modify many lines of code.
=== The Stack ===
In computer science, a stack is a dynamic data structure where data can be added and removed flexibly. Like a stack of books, the last element that was put on top must be taken and removed first (LIFO-structure - Last In, First Out). Adding an element is usually called “push”, and reading & removing “pop”.

Many processor architectures including ARM feature circuitry to deal with such a structure efficiently. Like most others, ARM does not provide a dedicated memory area for this - it just facilitates using an area that the programmer reserved for this purpose as a stack. Therefore, a part of the SRAM needs to be reserved for the stack.

On ARM, the program stores processor registers on the stack, i.e. 32bit per element. The stack is commonly used when the contents of some register will be needed again later after it has been overwritten by some complex operation that needs many registers. These accesses always come in pairs:

* Some operation that writes to r0
* '''Push''' (save) r0 to the stack
* Some operation that overwrites r0
* '''Pop''' (restore) r0 from the stack
* Use the value in r0 which is the same as initially assigned

ARM’s instructions for accessing the stack are unsurprisingly called “push” and “pop”. They can save/restore any of the registers r0-r12 and r14, for example:

<source lang=asm>
ldr r0, =1000000
@ Use r0 ...
push { r0 } @ Save value 1000000

@ … Some code that overwrites r0 …

pop { r0 } @ Restore value 1000000
@ Continue using r0 ...
</source>

It is also possible to save/restore multiple registers in one go:

<source lang=asm>
ldr r0, =1000000
ldr r1, =1234567
@ Use r0 and r1 ...
push { r0, r1 } @ Save values 1000000 and 1234567

@ … Some code that overwrites r0 and r1 …

pop { r0, r2 } @ Restore 1000000 into r0 and 1234567 into r2
@ Continue using r0 and r2...
</source>

It does not matter to which register the data is read back - in the previous example, the value that was held in r1 is restored into r2. In larger applications, many store-restore pairs will be nested:

<source lang=asm>
ldr r0, =1000000
@ Use r0 ...
push { r0 } @ Save value 1000000

@ Inner Code Block:

ldr r0, =123
@ Use r0 …

push { r0 } @ Save value 123

@ Inner-Inner Code Block that overwrites r0

pop { r0 } @ Restore value 123
@ Continue using r0 ...

pop { r0 } @ Restore value 1000000 into r0

@ Continue using r0 …
</source>

The “inner” push-pop pair works with value 123, and the “outer” push-pop pair works with value 1000000. Assuming that the stack was empty at the beginning, it will contain 1000000 after the first “push”, and both 1000000 and 123 after the second push. After the first “pop” it contains only 1000000 again, and is empty after the second “pop”.

At the beginning of a push-pop pair, the current contents of the stack is irrelevant - it may be empty or contain many elements. After the “pop”, the stack will be restored to its previous state. This makes it possible to (almost) arbitrarily nest push-pop-pairs - after any inner push-pop-pair has completed, the stack is in the same state as before entering the inner pair, so the “pop” part of the outer pair doesn’t even notice the stack was manipulated in between. This is why it is important to make sure that each “push” has a matching “pop”, and vice-versa.

As mentioned, an area of memory has to be reserved for the stack. Access to the stack memory is managed via the stack pointer (SP). The stack pointer resides in the processor register r13, and “sp” is an alias for that. As the name implies, the stack pointer contains a 32bit memory address - specifically, the address of the first byte in the stack that contains any saved data.

When storing a 32bit register value using “push”, the stack pointer is '''first''' decremented by 4 before the value is written at the newly calculated address. To restore a value, the address currently stored in the stack pointer is read from memory, after which the stack pointer is incremented by 4. This is called a “full-descending” stack (see the ARM Architecture Reference Manual, chapter B1.5.6). On ARMv7-A (Cortex-A), this behaviour can be changed, but on ARMv7-M, it is dictated by the exception handling logic, which will be explained later.

An implication of this is that if the stack is empty, the stack pointer contains the address of the first byte '''after''' the stack memory area. If the stack is completely full, it contains the address of the very first byte '''inside''' the stack memory area. This means that the stack grows '''downward'''. Since the stack is empty at program start, the stack pointer therefore needs to be initialized to the first address after the memory area. Before executing the first instruction, the processor loads the first 4 bytes from the flash into the stack pointer. This is why “_StackEnd” was defined and used to place the address of the first byte after the stack memory region into the first 4 bytes of flash.

The stack pointer must always be a multiple of 4 (see chapter B5.1.3 in the ARM Architecture Reference Manual). It is a common error (which is even present in the example projects by ST!) to initialize the stack pointer to the last address ''inside'' the stack memory area (e.g. 0x200003FF instead of 0x20000400), which is not divisible by four. This can cause the application to crash or “just” slow it down. Actually, the [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/ka4127.html ARM ABI requires] the stack pointer to be a multiple of 8 for public software interfaces, which is important for e.g. the “printf” C function. So, when calling any external code, make sure the stack pointer is a multiple of 8.

In the previous examples, the stack memory area was defined with a size of 0x400, i.e. 1KiB. Choosing an appropriate stack size is critical for an application; if it is too small, the application will crash, if it is too large, memory is wasted that could be used otherwise. Traditionally, the stack is configured to reside at the ''end'' of available memory, e.g. 0x20005000 for the STM32F103. As the linker starts allocating memory for data (using “.data” in assembly or global/static variables in C) at the beginning of the memory, the stack is as far away from that regular data as possible, minimizing the chance of a collision. However, if the stack grows continuously, the stack pointer might end up pointing into the regular data area (“.data” or C globals) or heap memory (used by “malloc” in C). In that case, writing to the stack silently overwrites some of the regular data. This can result in all kinds of hard to find errors. Therefore, the example codes put the stack area at the ''beginning'' of RAM, and the regular data after that - if the stack grows too large, the stack pointer will reach values below 0x20000000, and any access will result in an immediate “clean” crash. It is probably easy to find the code location that allocates too much stack memory, and possibly increase the stack size. Using the Cortex-M3’s memory protection unit (MPU) enables even more sophisticated strategies, but that is out of scope for this tutorial.
=== Function calls ===
Many programming languages feature a “function” concept. Also known as a “procedures” or “subprograms”, functions are the most basic building blocks of larger applications, and applying them correctly is key for clean, reusable code. The assembler does not know about functions directly, so you have to build them yourself. A function is a block of code (i.e. a sequence of instructions) that you can jump to, does some work, and then jumps back to the place from which the first jump originated. This ability to jump back is the main difference from any other block of assembly code. To make this explicit, such a jump to a function is known as a “call” (as in “calling a function”). The location in code that starts the jump to the function is known as the “caller”, and the called function as “callee”. From the perspective of the caller, calling a function resembles a “user-defined” instruction - it performs some operation after which the code of the caller continues as before. To make the jump back possible, the address of the ''next'' instruction after the one that started the function call needs to be saved, so that the function can jump back to that location (without calling the function directly again).

This is done via the Link Register (LR), which is the processor register r14. Function calls are performed with the “bl” instruction. This instruction performs a jump, much like the well-known “b”, but also saves the address of the next instruction in LR. When the function is finished, it returns to the caller by jumping to the address stored in LR. As already mentioned, jumping to a location from a register is called an indirect jump, which is performed by the “bx” instruction. So, to return from a function, use “bx lr”:

<source lang=asm>
.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:

bl EnableClockGPIOA @ Call function to enable GPIOA's peripheral clock

@ Some more code ...
ldr r1, =GPIOA_CRH
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1]

.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, =RCC_APB2ENR
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

</source>

Here, the code to enable the clock for GPIOA was packaged into a function. To enable this clock, only a single line is now required - “bl EnableClockGPIOA”.

When calling a function, the “bl” instruction automatically makes sure to set the lowest bit in LR such that the subsequent “bx lr” will not crash because of an attempted instruction set switch, which is not possible on Cortex-M. If you need to call a function indirectly, use “blx” with a register, and remember to ensure that the lowest bit is set, typically via “.type YourFunction, %function”. Usually, all the code of an application resides within functions, with the possible exception of the Reset_Handler. The order in which functions are defined in the source files does not matter, as the linker will always automatically fill in the correct addresses. If you want to put functions in separate source files, remember to use “.global FunctionName” to make sure the symbol is visible to other files.
==== Using the stack for functions ====
In large applications it is common for functions to call other functions in a deeply nested fashion. However, a function implemented as shown can’t do that - using “bl” would overwrite the LR, and so the return address of the outer function would be lost, and that function couldn’t ever return. The solution is to use the stack: At the beginning of a function that calls other functions, use “push” to save the LR, and at the end use “pop” to restore it. For example, the blink program could be restructured like this:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

RCC_APB2ENR = 0x40021018
RCC_APB2ENR_IOPAEN = 4
GPIOA_CRH = 0x40010804

GPIOA_BSRR = 0x40010810
GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000

GPIOx_CRx_GP_PP_2MHz = 2

DelayLoopIterations = 1000000

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
bl EnableClockGPIOA
bl ConfigurePA8
ldr r5, =5 @ Number of LED flashes.
bl Blink
b .

.type Blink, %function
Blink:
push { lr }
ldr r0, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r1, =GPIOx_BSRR_BS8 @ Register value to set pin to high
ldr r2, =GPIOx_BSRR_BR8 @ Register value to set pin to low
ldr r3, =DelayLoopIterations @ Iterations for delay loop

BlinkLoop:
str r1, [r0] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

bl Delay

str r2, [r0] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

bl Delay

subs r5, #1
bne BlinkLoop

pop { lr }
bx lr

.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, =RCC_APB2ENR
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.type ConfigurePA8, %function
ConfigurePA8:
ldr r1, =GPIOA_CRH
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2
bx lr

.type Delay, %function
Delay:
mov r4, r3
DelayLoop:
subs r4, #1
bne DelayLoop @ Iterate delay loop
bx lr

</source>
Example name: “BlinkFunctions”

The Reset_Handler just became much prettier. There now are functions for enabling the GPIOA clock, configuring PA8 as output, and one that delays execution so that the LED blinking is visible. The “Blink” function performs the blinking, but only for 5 flashes, after which it returns (an endless blink-loop wouldn’t be good for demonstrating returns). As you see, LR is saved on the stack to allow “Blink” to call further functions.

The two lines

<source lang=asm>
pop { lr }
bx lr
</source>

are actually longer than necessary. It is actually possible to directly load the return address from the stack into the program counter, PC:

<source lang=asm>
pop { pc }
</source>

This way, the return address that was saved on the stack is directly used for the jump back. Just the same way, you can use “push” and “pop” to save and restore any other registers while your function is running.
==== Calling Convention ====
Actually building a large program as shown in the last example is a bad idea. The “Delay” function requires 1000000 to reside in r4. The “Blink” function relies on “Delay” not overwriting r0-r2, and r5, and requires the number of flashes to be given via r5. Such requirements can quickly grow into an intricate web of interdependencies, that make it impossible to write larger functions that call several sub-functions or restructure anything. Therefore, it is common to use a calling convention, which defines which registers a function may overwrite, which it should keep, how it should use the stack, and how to pass information back to the caller.

When building an entire application out of your own assembly code, you can invent your own calling convention. However, it is always a good idea to use existing standards: The AAPCS defines a calling convention for ARM. This convention is also followed by C and C++ compilers, so using it makes your code automatically compatible with those. The Cortex-M interrupt mechanism follows it too, which would make it awkward to adapt code that uses some other convention to Interrupts. The specification of the calling convention is quite complex, so here is a quick summary of the basics:

* Functions may only modify the registers r0-3 and r12. If more registers are needed, they have to be saved and restored using the stack. The APSR may be modified too.
* The LR is used as shown for the return address.
* When returning (via “bx lr”) the stack should be exactly in the same state as during the jump to the function (via “bl”).
* The registers r0-r3 may be used to pass additional information to a function, called parameters, and the function may overwrite them.
* The register r0 may be used to pass a result value back to the caller, which is called the return value.

This means that when you call a function, you must assume registers r0-r3 and r12 may be overwritten but the others keep their values. In other words, the registers r0-r3 and r12 are (if at all) saved ''outside'' the function (“caller-save”), and the registers r4-r11 are (if at all) saved ''inside'' the function (“callee-save”).

A function that does not call any other functions is called a “leaf-function” (as it is a leaf in the call tree). If such a function is simple, it might not require to touch the stack at all, as the return value is just saved in a register (LR) and it might only overwrite the registers r0-r3 and r12, which the caller can make sure to contain no important data. This makes small functions efficient, as register accesses are faster than memory accesses, such as to the stack.

If all your functions follow the calling convention, you can call any function from anywhere and be sure about what it overwrites, even if it calls many other functions on its own. Restructuring the LED blinker could look like this:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

RCC_APB2ENR = 0x40021018
RCC_APB2ENR_IOPAEN = 4
GPIOA_CRH = 0x40010804

GPIOA_BSRR = 0x40010810
GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000

GPIOx_CRx_GP_PP_2MHz = 2

DelayLoopIterations = 1000000

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
bl EnableClockGPIOA
bl ConfigurePA8
ldr r0, =5
bl Blink
b .

.type Blink, %function
Blink:
push { r4-r7, lr }
ldr r4, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r5, =GPIOx_BSRR_BS8 @ Register value to set pin to high
ldr r6, =GPIOx_BSRR_BR8 @ Register value to set pin to low
mov r7, r0 @ Number of LED flashes.

BlinkLoop:
str r5, [r4] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r0, =DelayLoopIterations @ Iterations for delay loop
bl Delay

str r6, [r4] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

ldr r0, =DelayLoopIterations @ Iterations for delay loop
bl Delay

subs r7, #1
bne BlinkLoop

pop { r4-r7, pc }

.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, =RCC_APB2ENR
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.type ConfigurePA8, %function
ConfigurePA8:
ldr r1, =GPIOA_CRH
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2
bx lr

@ Parameters: r0 = Number of iterations
.type Delay, %function
Delay:
DelayLoop:
subs r0, #1
bne DelayLoop @ Iterate delay loop
bx lr
</source>
Example name: “BlinkFunctionCallingConvention”

The three small functions at the end only use registers r0 and r1, which they are free to overwrite. The “Delay” function expects the number of iterations as a parameter in r0, which it then modifies. Therefore, the “Blink” function fills r0 before every call to “Delay”. Alternatively, “Delay” could use a fixed iteration count, i.e. the “ldr” could be moved into “Delay”. As the “Blink” function must assume that “Delay” overwrites r0-r3 and r12, it keeps its own data in r4-r7, which are guaranteed to be retained according to the calling convention. Since “Blink”, in turn, must preserve these registers for the function that called it, it uses “push” and “pop” to save and restore them. Note the shortened syntax “r4-r7” in the instructions. The number of LED flashes is passed in r0 as a parameter; as this register will be overwritten, this number is moved to r7.

Alternatively, “Blink” could re-load the constants each time they are used in r1/r2, such that only one register (r4) needs to be saved as it is needed to count the number of flashes:

<source lang=asm>
.type Blink, %function
Blink:
push { r4, lr }

mov r4, r0

BlinkLoop:
ldr r1, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r2, =GPIOx_BSRR_BS8 @ Register value to set pin to high
str r2, [r1] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r0, =DelayLoopIterations @ Iterations for delay loop
bl Delay

ldr r1, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r2, =GPIOx_BSRR_BR8 @ Register value to set pin to low
str r2, [r1] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

ldr r0, =DelayLoopIterations @ Iterations for delay loop
bl Delay

subs r4, #1
bne BlinkLoop

pop { r4, pc }
</source>
Example name: “BlinkFunctionCallingConvention2”

A third variant would not use any of the callee-save-registers (r4-r11) at all, and instead just save r0 before the function calls and restore it as needed

<source lang=asm>
.type Blink, %function
Blink:
push { lr }

BlinkLoop:
push { r0 }

ldr r1, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r2, =GPIOx_BSRR_BS8 @ Register value to set pin to high
str r2, [r1] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r0, =DelayLoopIterations @ Iterations for delay loop
bl Delay

ldr r1, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r2, =GPIOx_BSRR_BR8 @ Register value to set pin to low
str r2, [r1] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

ldr r0, =DelayLoopIterations @ Iterations for delay loop
bl Delay

pop { r0 }
subs r0, #1
bne BlinkLoop

pop { pc }

</source>
Example name: “BlinkFunctionCallingConvention3”

The frequent stack accesses would however make this slower. Be sure to always document the meaning (and units, if applicable) of parameters e.g. via comments.
=== Conditional Execution ===
As mentioned, the conditional variants of the “b” instruction (e.g. “bne”) can be used to execute certain blocks of code only if a certain condition is met. First, more ways to formulate conditions will be shown. Next, the ARM instruction “it” will be introduced, which makes executing small blocks of code conditionally more efficient.
==== Conditions ====
All conditions for conditional execution depend on the outcome of some mathematical operation. When instructions such as “adds”, “subs”, “ands” are used, they update the flags in the APSR register depending on the outcome, which are then read by the conditional variants of “b” to decide whether to actually perform the jump.

Often it is necessary to compare two numbers without actually doing a calculation. This can be done with the “cmp” instruction to which you can pass two registers or a register and a literal:

<source lang=asm>
cmp r0, #42
cmp r0, r1
</source>

The “cmp” instruction is very similar to “subs” - it subtracts the second operand from the first, but doesn’t save the result anywhere, i.e. the registers keep their values. Just the flags in the APSR are updated according to the result, just as with “subs”. For example, if both operands were equal, the result of the subtraction is zero, and the zero flag will be set. So, to test whether two numbers are equal:

<source lang=asm>
cmp r0, #42
beq TheAnswer

@ This is executed if r0 is not 42

TheAnswer:
@ This is executed if r0 is 42
</source>

The “bne” instruction is the opposite of “beq”.

The “tst” instruction works similarly to “cmp”, but instead of subtracting, perform a bitwise “and” operation - like the “ands” instruction, but without keeping the result. This way, you can test whether a bit in a register is set:

<source lang=asm>
tst r0, #4
beq BitNotSet

@ This is executed if bit 2 in r0 is set

BitNotSet:
@ This is executed if bit 2 in r0 is not set
</source>

A more useful use case for “tst” is to pass the same register twice. Applying “and” to the same value twice yields the same result as the input, so “tst” in this case effectively checks the properties of the input (negative/positive, zero):

<source lang=asm>
tst r0, r0
beq ValueZero

@ This is executed if r0 is not zero

ValueZero:
@ This is executed if r0 is zero
</source>

There is also the “teq” instruction which performs an exclusive or operation.

As mentioned, the suffixes “eq” and “ne” are called condition codes. ARM has 14 of those which define how the flags in the APSR form the condition. The details about how a subtraction (by “subs” or “cmp”) sets the flags in the APSR and how their interpretation by the different condition codes correlates to the mathematical result are somewhat complicated, involving the way the 2’s complement format works and relying on the fact that subtracting works by adding a negated number. Instead of diving into all the details, a table with a more high-level view and a practical interpretation of the condition should be more helpful:

{| class="wikitable"
! style="text-align:left;" | Code
! style="text-align:left;" | Meaning
! style="text-align:left;" | Unsigned / Signed
! style="text-align:left;" | Flags
! style="text-align:left;" | Condition after “cmp/subs r0, r1”
! style="text-align:left;" | Condition after “tst r0, r1”
|-
| style="text-align:center;" | EQ
| Equal
| style="text-align:center;" | U+S
| Z==1
| r0 = r1
| r0 = 0
|-
| style="text-align:center;" | NE
| Not equal
| style="text-align:center;" | U+S
| Z==0
| r0 ≠ r1
| r0 ≠ 0
|-
| style="text-align:center;" | MI
| Negative
| style="text-align:center;" | S
| N==1
| ---
| r0 < 0
|-
| style="text-align:center;" | PL
| Positive or Zero
| style="text-align:center;" | S
| N==0
| ---
| r0 ≥ 0
|-
| style="text-align:center;" | VS
| Overflow
| style="text-align:center;" | S
| V==1
| r0-r1 out of range¹
| ---
|-
| style="text-align:center;" | VC
| No Overflow
| style="text-align:center;" | S
| V==0
| r0-r1 in range¹
| ---
|-
| style="text-align:center;" | HS
| Unsigned higher or same
| style="text-align:center;" | U
| C==1
| r0 ≥ r1
| ---
|-
| style="text-align:center;" | LO
| Unsigned lower
| style="text-align:center;" | U
| C==0
| r0 < r1
| ---
|-
| style="text-align:center;" | HI
| Unsigned higher
| style="text-align:center;" | U
| C==1 and Z==0
| r0 > r1
| ---
|-
| style="text-align:center;" | LS
| Unsigned lower or same
| style="text-align:center;" | U
| C==0 or Z==1
| r0 ≤ r1
| ---
|-
| style="text-align:center;" | GE
| Signed greater or equal
| style="text-align:center;" | S
| N==V
| r0 ≥ r1
| ---
|-
| style="text-align:center;" | LT
| Signed less than
| style="text-align:center;" | S
| N!=V
| r0 < r1
| ---
|-
| style="text-align:center;" | GT
| Signed greater than
| style="text-align:center;" | S
| Z==0 and N==V
| r0 > r1
| ---
|-
| style="text-align:center;" | LE
| Signed less or equal
| style="text-align:center;" | S
| Z==1 or N!=V
| r0 ≤ r1
| ---
|}
1: Range meaning the numbers from -(2^31) until (2^31-1), inclusive

To determine which condition code you need, first think about whether the number is unsigned (range 0 to 2^32-1) or is using two's complement to represent signed numbers (range -2^31 to 2^31-1). Ignore all rows in the table with the wrong format.

If you want to compare two numbers, use the “cmp” instruction, and search for the desired condition within the “cmp”-condition column of the table. If you want to test a single number's properties, use the “tst”-column. Use the condition code from the first column with the conditional “b” instruction (“bne”, “beq”, “bmi”, “bpl”, “bhs”, ... ) right after the appropriate “cmp”/”tst” instruction.

Note that all the condition codes have a corresponding inverse code that has exactly the negated meaning. Most also have a swapped partner code, using which is equivalent to swapping the operands for cmp.
==== The IT instruction ====
Jumping is inefficient, so having many conditional jumps may slow down your program. The ARM architecture offers a way to make a few instructions conditional without requiring a jump via the “it” (if-then) instruction. It is used in place of a conditional jump after an instruction that set the flags (“cmp”, “tst”, “adds”…) and also needs a condition code. The next instruction right after the it will then only be executed when the condition is met, and skipped otherwise. You have to repeat the condition code and add it to that instruction; this is just to make the code clearer and avoid confusion.

<source lang=asm>
ldr r4, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r5, =GPIOx_BSRR_BS8 @ Register value to set pin to high

ldr r0, =1 @ Load some date to compare
ldr r1, =2

cmp r0, r1 @ Perform comparison

it hi @ Make the next instruction conditional
strhi r5, [r4] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high
</source>

This checks if r0 is higher than r1 (it isn’t), and only sets the pin PA8 to high if this condition is met. Up to 4 instructions can be made conditional like this; for each one, an additional “t” has to be appended to the “it” instruction:

<source lang=asm>
cmp r0, r1 @ Perform comparison

ittt hi @ Make the next instruction conditional
ldrhi r4, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldrhi r5, =GPIOx_BSRR_BS8 @ Register value to set pin to high
strhi r5, [r4] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high
</source>

You can also add instructions that will be executed if the condition was ''not'' met (like an “else”-case in high-level-languages), by appending “e” instead of “t” to the “it” instruction. Since the “t” in “it” is fixed, the first instruction is always executed if the condition is met; only the next three instructions can be either a “then” case (“t”) or “else” case (“e”). You also have to provide the inverted condition code for the “else”-instructions:

<source lang=asm>
ldr r4, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r5, =GPIOx_BSRR_BS8 @ Register value to set pin to high
ldr r6, =GPIOx_BSRR_BR8 @ Register value to set pin to low

ldr r0, =1 @ Load some date to compare
ldr r1, =2

cmp r0, r1 @ Perform comparison

ite hi @ Make the next two instructions conditional (if-then-else)
strhi r5, [r4] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high
strls r6, [r4] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low
</source>

There are several restrictions on which instructions may appear within an it-block. Most importantly, instructions that set the flags are forbidden here, as is the “b” instruction except for the last instruction in an “it” block. Directly jumping to one of the conditional instructions is forbidden too.

In T32 code, only the conditional “b” instruction is capable of encoding a condition code together with some operation, so the “it” instruction is provided to make any instruction conditional. On A32, most instructions include a condition code and can therefore be conditional, and the “it” instruction is actually ignored by the assembler here. You can and should still put “it” into code intended for A32, as this makes it compatible with T32. This is one of the reasons why A32 is more time-efficient, and T32 more space-efficient.

Conditional instructions sometimes make surprisingly compact programs. For example, the euclidean algorithm for calculating the greatest common divisor (gcd) of two numbers can be written in ARM assembly like this:

<source lang=asm>
gcd:
cmp r0, r1
ite gt
subgt r0, r0, r1
suble r1, r1, r0
bne gcd
</source>

While the C equivalent is actually longer:

<source lang=asm>
int gcd(int a, int b) {
while (a != b) {
if (a > b)
a = a - b;
else
b = b - a;
}
return a;
}
</source>

The usage of conditional instructions is also [https://developer.arm.com/docs/dui0801/latest/condition-codes/example-showing-the-benefits-of-conditional-instructions-in-a32-and-t32-code faster] than using conditional jumps. Note that the final “bne” instruction is independent of the “if-then” block; it just directly uses the result of “cmp”.
=== 8/16 bit arithmetic ===
So far, all numbers had 32 bit. However, especially for space reasons, smaller numbers are needed with 8 or 16 bit. Cortex-M3 doesn't provide any instructions for calculating 8 or 16 bit numbers directly. Instead, after loading such a number from memory into a processor register, it has to be extended into 32bit to allow the 32bit instructions to work properly. When storing the result back, only the lower 8/16 bit are used. If 8/16bit overflow behavior is required (i.e. overflow at -128/127 for 8bit signed, 0/256 for 8bit unsigned, -32768/32767 for 16bit signed, 0/65536 for 16bit unsigned) for calculations, the numbers have to be truncated after each calculation. This actually makes it slightly less efficient to deal with smaller numbers.

A 16bit value (“halfword”) can be read from memory with the ldrh instruction:

<source lang=asm>
ldr r0, =SomeAddress
ldrh r1, [r0]
</source>

“ldrh” loads 16bit from memory, writes them into the lower 16 bits of the destination register (here: r1), and sets the upper 16bits to zero. If the value is signed, it has to be sign-extended so that it can be used with 32bit-calculations:

<source lang=asm>
ldr r0, =SomeAddress
ldrh r1, [r0]
sxth r1, r1
</source>

The “sxth” instruction copies the sign bit (i.e. bit 15) into the upper 16 bits (“sign-extension”); this makes sure that negative 16bit-numers keep their value when interpreted as 32 bits. The “ldrsh” instruction combines both “ldrh” and “sxth”. “ldrb”, “sxtb”, “ldrsb” are for loading and sign-extending 8bit-values and the combination of both, respectively.

To simulate 8/16bit overflow behaviour after a mathematical operation, use uxtb/uxth for unsigned 8/16 bit numbers, or sxtb/sxth for signed 8/16 bit numbers:

<source lang=asm>
add r0, #1
uxth r0, r0
</source>

The “uxth”/”uxtb” instructions copy the lower 16/8 bits of a register into another one, setting the upper 16/24 bits to zero. This way, if r0 contained 65535 before, the result will be 0 instead of 65536 after using “uxth”.

This is a common trap when coding in C - when using e.g. the "uint16_t" type for local variables such as loop counters, this implicitly requests 16bit overflow behavior, requiring the truncating after each calculation, even though the overflow may actually never happen. This is why e.g. uint16_fast_t should be used for local variables, as this is 32 bit on ARM, which is faster.
=== Alignment ===
There are certain restrictions on the address when accessing data in memory using the “str”/”ldr” variants:
* The “ldrd”/”strd”/”ldm”/”stm” instructions, which can load/store multiple registers at once, always require the address to be a multiple of 4. If it isn’t, the program will crash.
* The “ldr”/”str” instructions require the address to be a multiple of 4, and “strh”/”ldrh” require it to be a multiple of 2. If it isn’t, the behaviour depends on the ARM version:
** On ARMv6-M and before, the program will crash.
** On ARMv7-M:
*** If the CCR.UNALIGN_TRP is set to zero (the default), the access will be slow
*** If the CCR.UNALIGN_TRP bit is set to one, the program will crash, emulating the ARMv6-M behaviour

For “strb”/”ldrb” there are no such requirements.

The number of which the address needs to be a multiple of is called the “alignment” (e.g. 2-byte-alignment, 4-byte-alignment, …). An access with an address that is a multiple of 2/4 as specified above is called an “aligned access”; others are called “unaligned access” (which are slow or cause a crash).

Even though slow accesses may be acceptable, it is still a good idea to make sure all accesses are always correctly aligned in case the code is ported to an ARM version or operating system that requires it. The addresses of periphery registers are already aligned correctly, so there is no need to worry. When placing data in RAM however, you should make sure that the addresses of the individual elements that are accessed via one of the “ldr” variants are aligned properly. For example, if a previous example code was modified like this:

<source lang=asm>
.data
var2:
.space 1 @ Reserve 1 byte for memory block “var2”
var1:
.space 4 @ Reserve 4 bytes for memory block “var1”

.text
@ Instructions go here...
</source>

The address of “var1” will not be a multiple of 4, and an access via “ldr” would be unaligned. This could be improved by adding a space of 3 bytes in between:

<source lang=asm>
.data
var2:
.space 1 @ Reserve 1 byte for memory block “var2”
.space 3
var1:
.space 4 @ Reserve 4 bytes for memory block “var1”

.text
@ Instructions go here...
</source>

This would require you to keep in mind all the other things in memory that were declared before, which is impractical especially if multiple assembly files are used. Therefore, the assembler offers the “.align” directive:

<source lang=asm>
.data
var2:
.space 1 @ Reserve 1 byte for memory block “var2”
.align 2
var1:
.space 4 @ Reserve 4 bytes for memory block “var1”

.text
@ Instructions go here...
</source>

When using “.align X”, the assembler makes sure that the next address will be a multiple of 2^X, so in this case, a multiple of 2^2=4. The assembler will therefore insert 0 to 2^X-1 bytes of space. The section containing the directive in the object code file will also be marked to require that alignment, such that the linker will automatically place it at the appropriate location in address space.
=== Offset addressing ===
The various “ldr”/”str” instructions can optionally perform some calculation on the address before executing the memory access. What is shown for “ldr” here works for “str” and the variants for halfwords and bytes equivalently. There are several variants for this. This first one adds a fixed offset that is encoded within the instruction itself to the address:

<source lang=asm>
ldr r0, [r1, #8]
</source>

This adds 8 to r1 and uses the result as the address to access. The number can also be negative. This variant is useful for accessing members of a heterogeneous container organized like a C struct or the registers in a periphery module. For example, you can load the base address of a periphery module into a register, and then access the various registers using offset-addressing without having to load each address individually:

<source lang=asm>
GPIOA=0x40010800
GPIOx_CRH = 0x04
GPIOx_BSRR = 0x10

GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000

GPIOx_CRx_GP_PP_2MHz = 2

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
bl EnableClockGPIOA

ldr r1, =GPIOA

ldr r0, [r1, #GPIOx_CRH]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1, #GPIOx_CRH] @ Set CNF8:MODE8 in GPIOA_CRH to 2

ldr r0, =GPIOx_BSRR_BS8 @ Register value to set pin to high
str r0, [r1, #GPIOx_BSRR] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

b .
</source>
Example name: “OffsetAddressing”

This way, you can avoid repeated loads of similar addresses. This variant is also capable of writing the newly calculated address back into the address register by appending a “!”:

<source lang=asm>
ldr r0, [r1, #8]!
</source>

This will add 8 to r1, write the result into r1, and also use it as an address from which to load 4 bytes and store them into r0. The variant

<source lang=asm>
ldr r0, [r1], #8
</source>

works just the opposite - r1 is used as an address from which to load the data, and “r1+8” is written back to r1. The next variant adds two registers to obtain the memory address:

<source lang=asm>
ldr r0, [r1, r2]
</source>

This loads the data from the address calculated by “r1+r2”. The second register (here: r2) can also be optionally shifted left by a fixed number of bits in the range 0-3:

<source lang=asm>
ldr r0, [r1, r2, lsl #2]
</source>

This shifts r2 left by two bits (i.e. multiplies it by 4), adds it to r1, and uses that as the address (r2 itself is not modified).
=== Iterating arrays ===
The offset addressing mechanism is perfectly suited to iterating arrays. This could be used to make an array defining a sequence of LED flashes that is iterated by the LED blinker application. Such an array would contain the duration of each on-and off-cycle (as passed to the “Delay” function) and be placed in flash memory:

<source lang=asm>
.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
bl EnableClockGPIOA
bl ConfigurePA8
bl Blink
b .

.type Blink, %function
Blink:
push { r4-r8, lr }
ldr r4, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r5, =GPIOx_BSRR_BS8 @ Register value to set pin to high
ldr r6, =GPIOx_BSRR_BR8 @ Register value to set pin to low
ldr r7, =BlinkTable @ Move address of "BlinkTable" into r7
ldr r8, =BlinkTableEnd @ Move address of "BlinkTableEnd" into r8

BlinkLoop:
str r5, [r4] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r0, [r7], #4 @ Load delay iterations from table and increment address
bl Delay

str r6, [r4] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

ldr r0, [r7], #4 @ Load delay iterations from table and increment address
bl Delay

cmp r7, r8
blo BlinkLoop

pop { r4-r8, pc }

.align 2
.type BlinkTable, %object
BlinkTable:
.word 1000000, 1000000, 1000000, 1000000, 1000000, 1000000
.word 2500000, 1000000, 2500000, 1000000, 2500000, 1000000
.word 1000000, 1000000, 1000000, 1000000, 1000000, 1000000
BlinkTableEnd:
</source>
Example name: “BlinkPattern”

The “.word” directive is used to place a sequence of 32bit- numbers into flash memory. The label “BlinkTable” will refer the the start address of the array, and “BlinkTableEnd” to the first address ''after'' the array. These two addresses are loaded into registers before the loop. The “.align” directive is used to make sure the 32bit-words are stored at properly aligned addresses. Inside the loop, the “ldr” instruction is used to load a 32bit-word from the array and pass it to the “Delay” function. The r7 register is advanced by 4 bytes to the next 32bit-word. This is done twice, for the on-and off-time. At the end of the loop, the address register is compared with the address of “BlinkTableEnd” - until that address has been reached, the loop will continue.

Another possibility is to keep the base address of the array in a register, and increment another register that contains the offset:

<source lang=asm>
.type Blink, %function
Blink:
push { r4-r9, lr }
ldr r4, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r5, =GPIOx_BSRR_BS8 @ Register value to set pin to high
ldr r6, =GPIOx_BSRR_BR8 @ Register value to set pin to low
ldr r7, =BlinkTable @ Move address of "BlinkTable" into r7
ldr r8, =0
ldr r9, =18

BlinkLoop:
str r5, [r4] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldr r0, [r7, r8, lsl #2] @ Load delay iterations from table
add r8, #1
bl Delay

str r6, [r4] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

ldr r0, [r7, r8, lsl #2] @ Load delay iterations from table
add r8, #1
bl Delay

cmp r8, r9
blo BlinkLoop

pop { r4-r9, pc }
</source>
Example name: “BlinkPattern2”

Here, r8 is incremented in steps of 1 to denote the index in the array. The “lsl” syntax for “ldr” is used to multiply r8 by 4 (since each word is 4 bytes in size) and add it to r7, which contains the array’s base address. At the end of the loop, r8 is compared with 18, which is the number of entries in the array. This variant is actually less efficient, as it needs to keep both the base address and the index in registers and also has to increment the index in each iteration.
=== Literal loads ===

Regardless of architecture, any processor obviously needs to work with addresses in its own address space a lot. ARM can do calculations with its 32bit addresses just fine, but there is a bottleneck: The instruction set itself. To work with any address, it needs to be initially loaded into a processor register, but ARM instructions are only 16 or 32bit in size - not enough space for an arbitrary 32bit number plus the instruction encoding. Allowing even larger instructions (e.g. 40 bit) would complicate matters, so ARM instead uses several tricks to deal with this problem, which will be discussed here.

The “ldr r0, =1234” syntax allows you to load any arbitrary 32bit numbers, but is not actually a machine code instruction, but is translated by the assembler into one. In this chapter, the actual instructions for loading immediate numbers are discussed.

==== The “mov”-instruction ====
The most basic way of loading an immediate number into a register is the “mov” instruction:

<source lang=asm>
mov r0, #1234
</source>

This allows you to load any 16bit number (0 to 2^16-1) into a register. “mov” also includes some clever encodings that allow you to load certain commonly-used patterns:

* Any 32bit number that consists of one byte of arbitrary bits (i.e. 8 adjacent arbitrary bits) at any location, and zeros otherwise, e.g. 0x00000045, 0x00045000, 0x7f800000.
* Any 32bit number that consists of the same byte repeated 2 or 4 times in fixed places, as in 0x23002300, 0x00230023, 0x23232323
* The bit-wise negated result of any of these two patterns, e.g. 0xffffffba, 0xfffbafff, 0x807fffff or 0xdcffdcff. The assembler will actually use the “mvn” instruction for this, which works identically to “mov”, but negates the value.

By specifying a number that falls into one of these patterns, the assembler will automatically use the appropriate encoding. The first two ways of encoding numbers are not only available with “mov”, but also several other mathematical instructions that expect some immediate value: “add”, “and”, “bic”, “cmn”, “cmp”, “eor”, “mov”, “mvn”, “orn”, “orr”, “rsb”, “sbc”, “sub”, “teq”, “tst”. In the ARM Architecture Reference Manual, check the description of the instructions and look out for “ThumbExpandImm” to see whether it supports the first two patterns above.

You can also use the “mvn” instruction directly, e.g.:

<source lang=asm>
mov r0, #0xf807ffff
mvn r0, #0x07f80000
</source>

both lines are identical and write the number 0xf807ffff into r0.
==== The “movt” instruction ====
While supporting many common patterns, this does not allow arbitrary 32 bit numbers. One way to load any 32bit number is to split the number into two 16bit halves, and use both “mov” and “movt” to combine these two half-words into one register:

<source lang=asm>
mov r0, #0xabcd
movt r0, #0x1234
</source>

The “movt” instruction loads the given number into the upper 16 bits of the register, so this example loads 0x1234abcd into r0. The order is important, as “mov” overwrites the upper 16 bits with zeros, but “movt” keeps the lower 16 bits. If a single “mov” can't fit the desired number, the combination of “mov” and “movt” is the fastest way of loading any 32bit number. As two 32bit instructions are needed, this consumes 8 bytes of program memory. If you want to load the address of a symbol into a register, you need to tell the assembler to split it automatically. This can be achieved by prefixing the symbol with “:lower16:” or “:upper16:”, e.g.:

<source lang=asm>
movw r0, #:lower16:GPIOA_BSRR
movt r0, #:upper16:GPIOA_BSRR
</source>

Note that “movw” needs to be specified in this case to explicitly tell the assembler to use the “mov” variant that accepts 16bit numbers (which it otherwise does automatically when a direct value is given).
==== PC-relative loads ====
The other way of loading arbitrary 32bit values into registers is to place the value directly in flash memory, and load it from there using “ldr”:

<source lang=asm>
@ Some code …
mov r0, … address of Literal ...
ldr r1, [r0]
@ More code …
Literal:
.word 0x12345678
</source>

However, there is a Chicken-And-Egg problem - the address of “Literal” is a 32bit number itself, so how to load it into r0? Luckily, there is a register that contains a number close to the one needed - the program counter (PC, r15) indicates the address of the instruction currently being executed. By reading it and adding a small offset that fits into the instruction itself, the address of “Literal” can be obtained, provided that “Literal” is located close enough. Consider this example of the EnableClockGPIOA function:

<source lang=asm>
.align 2
.type EnableClockGPIOA, %function
EnableClockGPIOA:
add r1, pc, #12
ldr r1, [r1]
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.align 2
.word RCC_APB2ENR
</source>

The 32bit-value “RCC_APB2ENR” is stored in flash memory. The “add” instruction is used to add the offset 12 to the address of the instruction itself to obtain the address of said 32bit-value, which is then loaded via “ldr”. The offset 12 is actually not easy to calculate and even depends on the alignment of the “add” instruction itself (hence the “.align” to ensure a consistent example). The assembler is capable of doing the calculation on its own, for which the “adr” instruction is used:

<source lang=asm>
.align 2
.type EnableClockGPIOA, %function
EnableClockGPIOA:
adr r1, LiteralRCC_APB2ENR
ldr r1, [r1]
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.align 2
LiteralRCC_APB2ENR:
.word RCC_APB2ENR
</source>

The label LiteralRCC_APB2ENR refers to the address of the 32bit-value in memory. “adr” is actually a variant of “add” that instructs the assembler to calculate the offset and place it into the instruction itself, which then lets the processor add it to PC and write the result to r1. This address is then used by “ldr”.

The “adr” instruction is useful when the address of some literal is explicitly needed; for example, in the blinker program, it can be used to obtain the addresses of the array:

<source lang=asm>
adr r7, BlinkTable @ Move address of "BlinkTable" into r7
adr r8, BlinkTableEnd @ Move address of "BlinkTableEnd" into r8
</source>

However, for loading a single value, the address is actually not needed. In this case, “adr” and “ldr” can be combined:

<source lang=asm>
.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, LiteralRCC_APB2ENR
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.align 2
LiteralRCC_APB2ENR:
.word RCC_APB2ENR
</source>

This special variant of “ldr” lets the assembler calculate to offset as with “adr”, adds it to “PC” at runtime and loads the data found at the address into r1. This is much easier than the first variant, as all calculations are done automatically. It is still somewhat cumbersome having to write three lines just to obtain a single 32bit value. Therefore, the assembler offers this already introduced syntax:

<source lang=asm>
ldr r1, =RCC_APB2ENR
</source>

This is a special command for the assembler. If possible, the assembler will use the “mov” or “mvn” instruction to load the value. If the value won’t fit, it will be put into flash memory, and a “ldr” instruction as above will be used. In this case, the “ldr rX, =...” syntax is equivalent to the combination of specifying a label for the value, the “.word” directive and “ldr rX, <Label>”. Therefore, this syntax is usually the best way to load immediates.

The assembler places the literals at the end of the file. If the file is long, the offset will be too long for the “ldr” and “adr” instructions and the assembler will emit an error. You can instruct the assembler to place all literals that have been declared so far at a specific point using the “.ltorg” directive. It is recommended to place an “.ltorg” after each function (after the “bx lr”) - just make sure that execution will never reach there. If a single function is so long that an “.ltorg” at the end is too far away from “ldr”/”adr” at the beginning, you can place an “.ltorg” somewhere in the middle and jump over it with “b”.

In summary, the following rules can help make literal loads more efficient
* Avoid literal loads if possible; try to calculate needed values from other values that have already been loaded, possibly by using offset-addressing in “ldr”/”str”
* When accessing multiple registers of a single periphery module, load its base address once and use offset addressing to access the individual registers
* If you need a pointer to a location in flash memory, try using “adr”
* If speed is important, use “movw”+”movt” to load the value
* Else, use “ldr rX, =...” to have the assembler choose the optimal encoding
* Place “.ltorg” after each function

The “ldr … =” instruction can also be used to load any immediate 32bit value into the PC to cause a jump to that address, simply by specifying “pc” as the target register. If you perform an ordinary branch (via “b” or “bl”) to some function whose address is too far away from the current code location, the linker will insert a “wrapper” function that does exactly that to perform the “far” jump. That function is called a “veneer”.
=== The SysTick timer ===
An important aspect of many embedded systems is to control timing of technical processes. In the blinker example, the timing of the LED flashes was handled by having the processor execute dummy instructions to pass time. It is however virtually impossible to accurately predict the runtime of any piece of code on a complex processor such as ARM ones, and the runtime may vary among multiple runs and depending on the actual micro controller and its configuration. For a simple LED blinker this may be acceptable, but not for e.g. a closed loop controller for some mechanical actor. Therefore, almost all micro controllers and also application processors feature one or more hardware timers, which allow to measure time independently of the execution speed of the software. Timer features vary widely among different processors, but that basic idea is to increment or decrement some digital counter at each clock cycle and trigger some event when it reaches a certain value.

All ARMv7-M processors feature the so-called “SysTick”-Timer as part of the processor core itself. This is a rather simple 24bit-timer that counts from a configurable value back to zero, then resets to that value and triggers an event. This timer is frequently used as a time base for RTOS or other runtime libraries. The timer uses three periphery registers: “RVR” contains the value from which to count down. “CVR” contains the current value, and “CSR” contains some status and control bits. The timer can be used for the “Delay” function like this:

<source lang=asm>
SCS = 0xe000e000
SCS_SYST_CSR = 0x10
SCS_SYST_RVR = 0x14
SCS_SYST_CVR = 0x18

@ Parameters: r0 = Number of iterations
.type Delay, %function
Delay:
ldr r1, =SCS
add r0, r0, r0, lsl #1

str r0, [r1, #SCS_SYST_RVR]
ldr r0, =0
str r0, [r1, #SCS_SYST_CVR]

ldr r0, =5
str r0, [r1, #SCS_SYST_CSR]

DelayLoop:
ldr r0, [r1, #SCS_SYST_CSR]
tst r0, #0x10000
beq DelayLoop

ldr r0, =0
str r0, [r1, #SCS_SYST_CSR]

bx lr
</source>

The SysTick is part of the “System Control Space”, SCS. The SCS base address is defined as a symbol, and the relative addresses of the registers as well. The count value is stored in “RVR”, after which “CVR” has to be set to zero. The timer is started by writing “5” into the “CSR” register. The loop repeatedly reads the “CSR” register and continues until bit 16 is set. The “tst” instruction is used to perform an “and” operation with the register contents and an immediate value without keeping the result while just updating the flags. At the end, the “CSR” register is set to zero to disable the timer. The “add” instruction at the beginning is used to multiply the count value by 3: r0 is shifted left by one, i.e. multiplied by two, and then added to itself, as in r0*2^1+r0. This is a common trick to quickly multiply by constants. By including this multiplication, the duration is the same as with the previous “Delay” variant, which, on this microcontroller, uses about 3 cycles per loop iteration.

Managing timing this way (or any other kind of “Delay” function) is still not very accurate. The time needed to call the function, start the timer, return, and set the pins is added to the actual duration and may also vary each time. The timing errors accumulate over time - a clock implemented this way will quickly go wrong. The proper way to achieve accurate timing is to start the timer once, let it run continuously, and react to its events. The internal clock source used by the microcontroller is also quite inaccurate (up to 2.5% deviation), which can be improved upon by a quartz crystal (typical accuracy of e.g. 0.005%), which will be covered later. Reacting to events instead of calling a function that executes dummy code requires restructuring the program code, without using any kind of “Delay” function.

To do that, the timer is started once at program startup and kept running. After setting the LED pin, wait for the timer event, and repeat. In the last example, the values 3000000 and 7500000 are used for the timer register (3x1000000 and 3x2500000, respectively). Changing the timer value while it is running continuously is problematic, so one fixed value should be used; to achieve variable blinker duration, multiple timer events need to be counted. The greatest common denominator of the two numbers is 1500000, so to achieve the two different times, 2 and 5 timer events need to be registered, respectively. Since these numbers fit into a single byte, the table entries and corresponding access instructions are changed to byte. A function “StartSysTick” is implemented to start the timer once, and a function “WaitSysTick” to wait for a given number of timer events:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

RCC_APB2ENR = 0x40021018
RCC_APB2ENR_IOPAEN = 4
GPIOA_CRH = 0x40010804

GPIOA_BSRR = 0x40010810
GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000

GPIOx_CRx_GP_PP_2MHz = 2

SCS = 0xe000e000
SCS_SYST_CSR = 0x10
SCS_SYST_RVR = 0x14
SCS_SYST_CVR = 0x18
TimerValue=1500000

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
bl EnableClockGPIOA
bl ConfigurePA8
ldr r0, =TimerValue
bl StartSysTick
bl Blink
b .

.type Blink, %function
Blink:
push { r4-r8, lr }
ldr r4, =GPIOA_BSRR @ Load address of GPIOA_BSRR
ldr r5, =GPIOx_BSRR_BS8 @ Register value to set pin to high
ldr r6, =GPIOx_BSRR_BR8 @ Register value to set pin to low
adr r7, BlinkTable @ Move address of "BlinkTable" into r8
adr r8, BlinkTableEnd @ Move address of "BlinkTableEnd" into r9

BlinkLoop:
str r5, [r4] @ Set BS8 in GPIOA_BSRR to 1 to set PA8 high

ldrb r0, [r7], #1 @ Load delay iterations from table and increment address
bl WaitSysTick

str r6, [r4] @ Set BR8 in GPIOA_BSRR to 1 to set PA8 low

ldrb r0, [r7], #1 @ Load delay iterations from table and increment address
bl WaitSysTick

cmp r7, r8
blo BlinkLoop

pop { r4-r8, pc }

.align 2
.type BlinkTable, %object
BlinkTable:
.byte 2, 2, 2, 2, 2, 2
.byte 5, 2, 5, 2, 5, 2
.byte 2, 2, 2, 2, 2, 2
BlinkTableEnd:
.align 2

.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, =RCC_APB2ENR
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.type ConfigurePA8, %function
ConfigurePA8:
ldr r1, =GPIOA_CRH
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2
bx lr
.ltorg

@ r0 = Count-Down value for timer
.type InitializeSysTick, %function
StartSysTick:
ldr r1, =SCS

str r0, [r1, #SCS_SYST_RVR]
ldr r0, =0
str r0, [r1, #SCS_SYST_CVR]

ldr r0, =5
str r0, [r1, #SCS_SYST_CSR]

bx lr

@ r0 = Number of timer events to wait for
.type WaitSysTick, %function
WaitSysTick:
ldr r1, =SCS

WaitSysTickLoop:
ldr r2, [r1, #SCS_SYST_CSR]
tst r2, #0x10000
beq WaitSysTickLoop

subs r0, #1
bne WaitSysTickLoop

bx lr

</source>
Example name: “BlinkSysTick”

This way, the blinker frequency will be as stable and accurate as possible with the given clock source.
=== Exceptions & Interrupts ===
Exceptions and interrupts play an important role in low-level development. They provide a facility for hardware to notify the software of events, such as received data blocks or a timer event. On ARM, interrupts are a sub-group of exceptions – there are some “system-level” exceptions mostly for dealing with processor errors and providing operating system support, while interrupts are “special” exceptions for events signaled by periphery modules. When writing “regular” microcontroller software, you will mostly work with interrupts.

Exceptions (and interrupts) interrupt normal program flow, and cause the processor to execute some other piece of code which is called the exception handler or Interrupt Service Routine (ISR) (even for the “system-level” exceptions that are not interrupts). After dealing with the indicated event, the ISR typically returns and normal program flow resumes. As exceptions can interrupt the program anytime, data (and periphery) may be in any kind of inconsistent state, so special care must be taken to avoid corrupting program state in an ISR. The ARMv7-M processor (including the Cortex-M3) provide sophisticated support for exceptions, with configurable priorities and nested exception calls. This chapter will only cover the basics for using exceptions.

On ARMv7-M, exception handlers are implemented as regular functions, for example:

<source lang=asm>
.type SysTick_Handler, %function
.global SysTick_Handler
SysTick_Handler:
@ Handle event ...
bx lr
</source>

Like any other function, it has a label, returns with “bx lr”, and is also made globally visible to other source files using “.global”. The “.type … %function” is required here for the same reason as for the already-mentioned “Reset_Handler”. Exception handlers can be located anywhere in flash memory, among the other regular functions. To tell the processor where the exception handlers for the various exception types are located, the vector table needs to be adjusted. Until now, the vector table was defined as:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.section .VectorTable, "a"
.word _StackEnd
.word Reset_Handler
.space 0xe4
</source>

Recall that the first 32bit-word in flash memory contains the initial stack pointer (defined via “.word _StackEnd”) and the second word contains the address of the first instruction of the program (defined via “.word Reset_Handler”). Actually, resetting the controller is an exception too, and the code to be executed after reset (or start-up) is the handler for the reset exception (hence the name “Reset_Handler”). The next 228 bytes of flash memory contain 57 32bit-addresses of the handlers of the other exceptions, including interrupts. The “.space” directive just fills those with zeroes. To tell the processor the address of an exception handler, the appropriate entry in this table needs to be set to that address. In chapter 10.1.2, table 63 of the controller’s reference manual, the format of the vector table, and which exception’s address should go where, is defined. Only the interrupts up until position 42 actually exist on the STM32F103RB/C8, as defined in chapter 2.3.5 of the datasheet; everything from “TIM8_BRK” is only present on larger controllers. According to the table, the SysTick exception handler’s address needs to be put at location 0x3C relative to the beginning of flash memory. Since the first 8 bytes are already occupied, 0x34 bytes of space are needed after those first 8 bytes.

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.section .VectorTable, "a"
.word _StackEnd
.word Reset_Handler
.space 0x34
.word SysTick_Handler
.space 0xac
</source>

With this modification, the SysTick_Handler function is now declared as the handler for the SysTick exception. By default, the SysTick timer does not trigger an exception. To do that, you have to set bit 2 in the SCS_SYST_CSR register. By placing the logic for the blinker into the timer's ISR, you get an interrupt-based blinker:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

RCC_APB2ENR = 0x40021018
RCC_APB2ENR_IOPAEN = 4
GPIOA_CRH = 0x40010804

GPIOA_BSRR = 0x40010810
GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000

GPIOx_CRx_GP_PP_2MHz = 2

SCS = 0xe000e000
SCS_SYST_CSR = 0x10
SCS_SYST_RVR = 0x14
SCS_SYST_CVR = 0x18
TimerValue=1500000

.data
Variables:
BlinkStep:
.space 1
TimerEvents:
.space 1

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
ldr r0, =Variables
ldr r1, =0
str r1, [r0, #(BlinkStep-Variables)]
ldr r1, BlinkTable
str r1, [r0, #(TimerEvents-Variables)]

bl EnableClockGPIOA
bl ConfigurePA8

ldr r1, =GPIOx_BSRR_BS8
ldr r0, =GPIOA_BSRR @ Load address of GPIOA_BSRR
str r1, [r0]

ldr r0, =TimerValue
bl StartSysTick
SleepLoop:
wfi
b SleepLoop

.type SysTick_Handler, %function
.global SysTick_Handler
SysTick_Handler:
ldr r0, =SCS
ldr r0, [r0, #SCS_SYST_CSR]
tst r0, #0x10000
beq Return

ldr r0, =Variables

ldrb r1, [r0, #(BlinkStep-Variables)]

cmp r1, #(BlinkTableEnd-BlinkTable)
bhs Return

ldrb r3, [r0, #(TimerEvents-Variables)]
subs r3, #1

itt ne
strbne r3, [r0, #(TimerEvents-Variables)]
bne Return

add r1, #1
cmp r1, #(BlinkTableEnd-BlinkTable)
bhs SkipRestart

ldr r2, =BlinkTable
ldrb r3, [r2, r1]
strb r3, [r0, #(TimerEvents-Variables)]

SkipRestart:
strb r1, [r0, #(BlinkStep-Variables)]

ands r1, #1
ite eq
ldreq r1, =GPIOx_BSRR_BS8
ldrne r1, =GPIOx_BSRR_BR8

ldr r0, =GPIOA_BSRR @ Load address of GPIOA_BSRR
str r1, [r0]

Return:
bx lr

.align 2
BlinkTable:
.byte 2, 2, 2, 2, 2, 2
.byte 5, 2, 5, 2, 5, 2
.byte 2, 2, 2, 2, 2
BlinkTableEnd:

.align 2

.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, =RCC_APB2ENR
ldr r0, [r1]
orr r0, r0, #RCC_APB2ENR_IOPAEN
str r0, [r1] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.type ConfigurePA8, %function
ConfigurePA8:
ldr r1, =GPIOA_CRH
ldr r0, [r1]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1] @ Set CNF8:MODE8 in GPIOA_CRH to 2
bx lr
.ltorg

@ r0 = Count-Down value for timer
.type InitializeSysTick, %function
StartSysTick:
ldr r1, =SCS

str r0, [r1, #SCS_SYST_RVR]
ldr r0, =0
str r0, [r1, #SCS_SYST_CVR]

ldr r0, =7
str r0, [r1, #SCS_SYST_CSR]

bx lr

</source>
Example name: “BlinkSysTickInterrupt”

The regular program flow now consists only of initializing the periphery, timer, and the first step of the blinker (setting the pin high). After that, the processor should do nothing but wait for exceptions, which is achieved by a simple endless loop. The “wfi” instruction suspends the processor; when an exception occurs, the processor will wake up, execute the ISR, and return execution after the “wfi”. Therefore, “wfi” is usually put in an endless loop as shown. This technique can reduce the processor’s power consumption significantly, as it is only running when something needs to be done, as indicated via interrupts. The ISR first checks whether the interrupt flag in the timer register is set - this is necessary, since exceptions can sometimes occur “spuriously”, i.e. without an actual event causing it. The decision whether to set or reset the pin state is taken based on the lowest bit of the table index, such that the output alternates between 1 and 0.

The code inside the ISR needs to know which step in the blinking sequence is currently active, and how many timer events have already occurred inside the current step. Therefore, two 1-byte-variables are stored in RAM. To access them, offset addressing is used, where r0 contains the base address of the variables in memory, and the offsets inside “ldrb” and “strb” are set accordingly. The last number of the blink sequence table is omitted, since it is actually superfluous, because no action is taken after the last delay has elapsed. Because the table size is now odd, an “.align” directive after it is required. Always putting “.align” after outputting data is a good idea anyways.

Since exceptions can occur at any point in regular program flow, the processor registers may contain some data that will be used after the exception handler returns. Therefore, if the exception handler writes anything into the registers, they need to be restored when returning from the exception. Upon exception entry, the Cortex-M3/4 processors automatically store the registers r0-r3, r12, r14 (LR) and APSR (including the flags) on the stack. The link register is filled with a special “dummy” value, and when the exception handler returns via “bx lr” using this value, the processor restores said registers to their previous state. This effectively means that you can implement exception handlers like any other function, i.e. freely overwrite r0-r3, r12 and the flags and push/pop r4-r11 and the LR if needed.
=== Macros ===
The assembler provides a few mechanisms to make assembly-language development easier. One of those are macros, which allow you to define snippets of assembly code that you can then insert easily whenever you need them. While looking similar to function invocations, the code inside the macro is actually copied each time the macro is used, so don’t overuse them. Macros are started with “.macro” and end at the next “.endm” directive. For example, the following macro sets the LED pin to 0 or 1:

<source lang=asm>
.macro SETLED value
ldr r0, =GPIOA_BSRR
ldr r1, =(((!\value) << 24) | (\value<<8))
str r1, [r0]
.endm

SETLED 0
SETLED 1
.endm
</source>

The macro name is defined as “SETLED”, and a single parameter with name “value” is given. By typing “\type”, the value of the parameter is substituted in the macro body. Some bit-shifting is used to calculate the right bit pattern to write into BSRR to set or reset the pin accordingly.
=== Weak symbols ===
As explained before, labels defined in assembly files get translated into symbols in the object code files, which are resolved by the linker. Sometimes it is desirable to provide a “default” or “fallback” implementation of some function (or data block) which is only used when no other implementation is given. This can be achieved by marking the “fallback” variant with “.weak”:

<source lang=asm>
.type Function1, %function
.global Function1
.weak Function1
Function1:
@ Default implementation …
…
bl Function1 @ Call the function
</source>

With this code alone, “Function1” will be used normally. If you put another function with the same name in a different assembly source file, that second variant will be used.
=== Symbol aliases ===
It is also possible to define aliases for symbols using “.thumb_set”, which sets the address accordingly. For example:

<source lang=asm>
.type Function1, %function
.global Function1
Function1:
@ Some Code

.thumb_set Function2, Function1
…
bl Function2 @ Call the function
</source>

When trying to call “Function2”, the linker will automatically fill in the address of “Function1”. This can also be combined with “.weak” to define a weak alias:

<source lang=asm>
.type Function1, %function
.global Function1
Function1:
@ Some Code

.weak Function2
.thumb_set Function2, Function1
…
bl Function2 @ Call the function
</source>

If you now define another “Function2” in a different assembly source file, that will be used. If not, “Function1” will be called, which is the target of the alias definition. This is useful if you want to define one default implementation for several different functions, for each of which you need one “.weak” and one “.thumb_set” directive.
=== Improved vector table ===
The techniques from the last three sections can be used to improve the definition of the vector table. The way it was defined before is not very flexible; to insert new entries, you have to calculate the new gap sizes and offsets. First, define a default handler ISR that is called by exceptions for which no other ISR is defined, and a macro that defines an alias for one exception with the default handler as the target, and finally a table of all exceptions by using the macro:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.macro defisr name
.global \name
.weak \name
.thumb_set \name, Default_Handler
.word \name
.endm

.global VectorTable
.section .VectorTable, "a"
.type VectorTable, %object
VectorTable:
.word _StackEnd
defisr Reset_Handler
defisr NMI_Handler
defisr HardFault_Handler
defisr MemManage_Handler
defisr BusFault_Handler
defisr UsageFault_Handler
.word 0
.word 0
.word 0
.word 0
defisr SVC_Handler
defisr DebugMon_Handler
.word 0
defisr PendSV_Handler
defisr SysTick_Handler
defisr WWDG_IRQHandler
defisr PVD_IRQHandler
defisr TAMPER_IRQHandler
defisr RTC_IRQHandler
defisr FLASH_IRQHandler
defisr RCC_IRQHandler
defisr EXTI0_IRQHandler
defisr EXTI1_IRQHandler
defisr EXTI2_IRQHandler
defisr EXTI3_IRQHandler
defisr EXTI4_IRQHandler
defisr DMA1_Channel1_IRQHandler
defisr DMA1_Channel2_IRQHandler
defisr DMA1_Channel3_IRQHandler
defisr DMA1_Channel4_IRQHandler
defisr DMA1_Channel5_IRQHandler
defisr DMA1_Channel6_IRQHandler
defisr DMA1_Channel7_IRQHandler
defisr ADC1_2_IRQHandler
defisr USB_HP_CAN1_TX_IRQHandler
defisr USB_LP_CAN1_RX0_IRQHandler
defisr CAN1_RX1_IRQHandler
defisr CAN1_SCE_IRQHandler
defisr EXTI9_5_IRQHandler
defisr TIM1_BRK_IRQHandler
defisr TIM1_UP_IRQHandler
defisr TIM1_TRG_COM_IRQHandler
defisr TIM1_CC_IRQHandler
defisr TIM2_IRQHandler
defisr TIM3_IRQHandler
defisr TIM4_IRQHandler
defisr I2C1_EV_IRQHandler
defisr I2C1_ER_IRQHandler
defisr I2C2_EV_IRQHandler
defisr I2C2_ER_IRQHandler
defisr SPI1_IRQHandler
defisr SPI2_IRQHandler
defisr USART1_IRQHandler
defisr USART2_IRQHandler
defisr USART3_IRQHandler
defisr EXTI15_10_IRQHandler
defisr RTCAlarm_IRQHandler
defisr USBWakeUp_IRQHandler

.text

.type Default_Handler, %function
.global Default_Handler
Default_Handler:
bkpt
b.n Default_Handler
</source>

There are a few empty entries in the table that are not used by the processor. At the beginning, there is still the definition for the initial stack pointer and the “Reset_Handler”. If you replace your “vectortable.S” by this code, you get a “proper” vector table. The “SysTick_Handler” will continue to work as before, and if you need to define any other ISR, for example for USART1, just define a function by the exact name “USART1_IRQHandler”. The address of this function will automatically be put in the vector table. If an exception without a corresponding ISR occurs, the “Default_Handler” will be called, which uses the “bkpt” instruction to force a breakpoint via the attached debugger. This helps debugging missed exceptions while avoiding to define several individual dummy handler functions.
=== .include ===
Having to put the register and bit definitions (“RCC_APB2ENR”, “RCC_APB2ENR_IOPAEN”, ...) in each assembly source file is redundant and error-prone. Instead, you can put them into a separate file (e.g. called “stm32f103.inc”) and use the “.include” directive to reference it:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.include "stm32f103.inc"

@ Normal code ...
</source>

The assembler will read the code from the included file and pretend it was written instead of the “.include” line. This can help improve code structure. While working on the project structure, you can also restructure the definitions for the GPIO registers to facilitate offset addressing:

<source lang=asm>
GPIOA = 0x40010800

GPIOx_CRH = 0x4
GPIOx_BSRR = 0x10
GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000
</source>

The next example incorporates these changes in addressing the registers.
=== Local Labels ===
Having to invent unique labels for all jump targets inside functions (e.g. for conditional code and loops) can be tedious. When using a disassembler (see below), each label will appear as its own functions. Therefore, the GNU assembler supports local labels. These are labels whose name consist only a number. Local names need not be unique; several labels called e.g. “1” may exist in one file. To perform a jump to a local label, use the number and append a “f” or “b” to indicate whether to jump forward or backward. Local labels can not be exported with the “.global” directive. The interrupt-based blinker can be modified like this using local labels:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.include "stm32f103.inc"

TimerValue=1500000

.data
Variables:
BlinkStep:
.space 1
TimerEvents:
.space 1

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
ldr r0, =Variables
ldr r1, =0
str r1, [r0, #(BlinkStep-Variables)]
ldr r1, BlinkTable
str r1, [r0, #(TimerEvents-Variables)]

bl EnableClockGPIOA
bl ConfigurePA8

ldr r1, =GPIOx_BSRR_BS8
ldr r0, =GPIOA @ Load address of GPIOA_BSRR
str r1, [r0, #GPIOx_BSRR]

ldr r0, =TimerValue
bl StartSysTick
1:
wfi
b 1b

.type SysTick_Handler, %function
.global SysTick_Handler
SysTick_Handler:
ldr r0, =SCS
ldr r0, [r0, #SCS_SYST_CSR]
tst r0, #0x10000
beq 2f

ldr r0, =Variables

ldrb r1, [r0, #(BlinkStep-Variables)]

cmp r1, #(BlinkTableEnd-BlinkTable)
bhs 2f

ldrb r3, [r0, #(TimerEvents-Variables)]
subs r3, #1

itt ne
strbne r3, [r0, #(TimerEvents-Variables)]
bne 2f

add r1, #1
cmp r1, #(BlinkTableEnd-BlinkTable)
bhs 1f

ldr r2, =BlinkTable
ldrb r3, [r2, r1]
strb r3, [r0, #(TimerEvents-Variables)]

1:
strb r1, [r0, #(BlinkStep-Variables)]

ands r1, #1
ite eq
ldreq r1, =GPIOx_BSRR_BS8
ldrne r1, =GPIOx_BSRR_BR8

ldr r0, =GPIOA @ Load address of GPIOA_BSRR
str r1, [r0, #GPIOx_BSRR]

2:
bx lr

.align 2
.type BlinkTable,%object
BlinkTable:
.byte 2, 2, 2, 2, 2, 2
.byte 5, 2, 5, 2, 5, 2
.byte 2, 2, 2, 2, 2
BlinkTableEnd:

.align 2

.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, =RCC
ldr r0, [r1, #RCC_APB2ENR]
orr r0, r0, #(1 << RCC_APB2ENR_IOPAEN)
str r0, [r1, #RCC_APB2ENR] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.type ConfigurePA8, %function
ConfigurePA8:
ldr r1, =GPIOA
ldr r0, [r1, #GPIOx_CRH]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1, #GPIOx_CRH] @ Set CNF8:MODE8 in GPIOA_CRH to 2
bx lr
.ltorg

@ r0 = Count-Down value for timer
.type InitializeSysTick, %function
StartSysTick:
ldr r1, =SCS

str r0, [r1, #SCS_SYST_RVR]
ldr r0, =0
str r0, [r1, #SCS_SYST_CVR]

ldr r0, =7
str r0, [r1, #SCS_SYST_CSR]

bx lr
</source>
Example name: “BlinkLocalLabels”
=== Initializing RAM ===
The blinker program uses 2 byte-variables in memory, which have to be initialized to some value at startup. For large programs with many variables, this quickly becomes hard to maintain and also inefficient. Assembler and linker can help producing an “image” of how the RAM contents should look like after initializing, and place this image in flash memory alongside the normal program data. At startup, this image can be simply copied 1:1 into RAM in a loop. Most programs contain many variables that will be initialized with zero, so placing a (possibly large) block of zeroes in flash memory is wasteful; therefore, an additional loop is used to initialize all zero-variables to zero. Both techniques are also employed by C and C++ compilers, so implementing the initialization code is required there too. First, change the declaration of your variables by using “.byte”, “.hword” and “.word” and include the desired initialization value. Variables that should be initialized by zero get to be placed after a “.bss” directive to put them into the equally-named section. They don’t get an initialization value but just reserved space by using “.space”:

<source lang=asm>
.data
TimerEvents:
.byte 2

.bss
BlinkStep:
.space 1
</source>

From the assembler’s point of view, the initialization data - in this case, just one byte of value “2” - will directly end up in RAM. However, this is not possible on microcontrollers, as the RAM always contains random data on startup and isn’t automatically initialized. To achieve that, change the linker script as follows:

<source>
MEMORY {
FLASH : ORIGIN = 0x8000000, LENGTH = 128K
SRAM : ORIGIN = 0x20000000, LENGTH = 20K
}

SECTIONS {
.VectorTable : {
*(.VectorTable)
} >FLASH

.text : {
*(.text)
. = ALIGN(4);
} >FLASH

.stack (NOLOAD) : {
. = . + 0x400;
_StackEnd = .;
} >SRAM

.data : {
_DataStart = .;
*(.data);
. = ALIGN(4);
_DataEnd = .;
} >SRAM AT >FLASH

_DataLoad = LOADADDR(.data);

.bss : {
_BssStart = .;
*(.bss);
. = ALIGN(4);
_BssEnd = .;
} >SRAM
}
</source>
Example name: “BlinkInitRAM”

The stack got put in its own section with the “NOLOAD” attribute, since it doesn’t need initializing. The data is now put in the “.data” section. The initial data for that section is put into flash memory via the “>SRAM AT >FLASH” construct. The addresses of symbols inside the “.data” section are still the addresses in RAM, so accesses to the symbols from assembly code still work. The symbol “_DataStart” is assigned the beginning of the initialized data in RAM, and “_DataEnd” the end. The “LOADADDR” function is used to get the beginning of the initialization data in flash, and assign it to “_DataLoad”. The “.bss” section contains all the variables that should be zero-initialized, and the symbols “_BssStart” and “_BssEnd” are set to its beginning and end address, respectively. As the beginning and size of the stack are already a multiple of 4, the beginning of “.data” is as well. The size of .data might not be a multiple of 4 however, so an “.=ALIGN(4)” command is inserted right before the definition of “_DataEnd”. This adds 0-3 dummy bytes by incrementing the location counter to make sure the address is a multiple of 4. The same thing is done right before “_BssEnd” and also at the end of the “.text” section, to make sure that “_BssEnd” and “_DataLoad” are multiples of 4 as well.

The only thing left is the actual initialization of the RAM. To do that, change the “Reset_Handler” as follows:

<source lang=asm>
.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
ldr r0, =_DataStart
ldr r1, =_DataEnd
ldr r2, =_DataLoad

b 2f
1: ldr r3, [r2], #4
str r3, [r0], #4
2: cmp r0, r1
blo 1b

ldr r0, =_BssStart
ldr r1, =_BssEnd
ldr r2, =0

b 2f
1: str r2, [r0], #4
2: cmp r0, r1
blo 1b

bl EnableClockGPIOA
bl ConfigurePA8

ldr r1, =GPIOx_BSRR_BS8
ldr r0, =GPIOA @ Load address of GPIOA_BSRR
str r1, [r0, #GPIOx_BSRR]

ldr r0, =TimerValue
bl StartSysTick
1:
wfi
b 1b
.ltorg
</source>

The explicit initialization of the variables was removed. Instead, the addresses for “_DataStart”, “_DataEnd” and “_DataLoad” that were defined in the linker script are loaded. Then, a short loop repeatedly loads a word from flash (i.e. starting with “_DataLoad”) and stores it into RAM (starting at “_DataStart”). The address pointers are incremented by the “ldr”/”str” instructions after the access. The pointer for the RAM location is compared with the end of the RAM area (“_DataEnd”) to decide whether to jump back to the beginning of the loop. To start the loop, a jump directly to the comparison is performed; this avoids the need to do the comparison at the beginning and inside of the loop. The second loop performs the zero-initialization of the area between “_BssStart” and “_BssEnd”; it works similarly, but does not need to load any data.

Unfortunately, the program as shown can’t be translated - as the two variables now reside in two different sections (“.data” and “.bss”), the offset addressing in the “SysTick_Handler” doesn’t work anymore. Therefore, direct addressing has to be used:

<source lang=asm>
.type SysTick_Handler, %function
.global SysTick_Handler
SysTick_Handler:
ldr r0, =SCS
ldr r0, [r0, #SCS_SYST_CSR]
tst r0, #0x10000
beq 2f

ldr r0, =BlinkStep

ldrb r1, [r0]

cmp r1, #(BlinkTableEnd-BlinkTable)
bhs 2f

ldr r0, =TimerEvents
ldrb r3, [r0]
subs r3, #1

itt ne
strbne r3, [r0]
bne 2f

add r1, #1
cmp r1, #(BlinkTableEnd-BlinkTable)
bhs 1f

ldr r2, =BlinkTable
ldrb r3, [r2, r1]
strb r3, [r0]

1:
ldr r0, =BlinkStep
strb r1, [r0]

ands r1, #1
ite eq
ldreq r1, =GPIOx_BSRR_BS8
ldrne r1, =GPIOx_BSRR_BR8

ldr r0, =GPIOA @ Load address of GPIOA_BSRR
str r1, [r0, #GPIOx_BSRR]

2:
bx lr
</source>
=== Peripheral interrupts ===
Interrupts, i.e. exceptions called by periphery modules, need a little extra code compared to the “core” exceptions including the SysTick. The Cortex-M’s interrupt controller (the NVIC) contains several registers for configuring these interrupts. It is possible to configure the priority and manually trigger interrupts, but for most applications, the only necessary thing to do is enabling the desired interrupt. This is done via the registers “NVIC_ISER0” through “NVIC_ISER15”, which are documented in the ARMv7M Architecture Reference Manual in chapter B3.4.4. Each of those registers contains 32 bits with which 32 of the interrupts can be enabled. The STM32F103RB/C8 has 43 interrupts, so only two of the possible 16 registers are present. The number of interrupts is given in chapter 2.3.5 of the controller’s datasheet. So, to enable some interrupt x, the bit “x mod 32” in register NVIC_ISER''y'' with y=x/32 has to be set. This register’s address is 0xE000E100+y*4. Given an interrupt’s number in r0, the following function does just that:

<source lang=asm>
NVIC_ISER0 = 0xE000E100

@ r0 = IRQ Number
.type EnableIRQ, %function
EnableIRQ:
ldr r1, =NVIC_ISER0

movs r2, #1
and r3, r0, #0x1F
lsls r2, r2, r3

lsrs r3, r0, #5
lsls r3, r3, #2

str r2, [r1, r3]

bx lr
.ltorg
</source>
Example name: “BlinkTIM1”

The “and” instruction calculates “x mod 32”, and the following left-shift (“lsls”) calculates the value where bit “x mod 32” is one, and all others are zero. To calculate the offset address “y*4”, i.e. “(x/32)*4”, the register is first shifted right by 5 bits and then shifted back left by 2 bits. This is the same as shifting 3 bits right and zeroing out the lower 2 bits; but two shift instructions actually consume less program memory space. Finally, the calculated value is written into the register by using offset addressing.

In addition to enabling the interrupt in the processor core’s NVIC, it also has to be enabled in the periphery module. Many periphery modules support several different events, each of which has to be enabled in the periphery’s register individually. Depending on the controller, these can be mapped to one single processor interrupt (and hence, one single ISR) or multiple ones, and need to be configured in the NVIC appropriately.

This example uses the STM32’s periphery timer TIM1 instead of the SysTick timer:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.include "stm32f103.inc"

TimerValue=1500
TimerPrescaler=1000

.data
TimerEvents:
.byte 2

.bss
BlinkStep:
.space 1

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
ldr r0, =_DataStart
ldr r1, =_DataEnd
ldr r2, =_DataLoad

b 2f
1: ldr r3, [r2], #4
str r3, [r0], #4
2: cmp r0, r1
blo 1b

ldr r0, =_BssStart
ldr r1, =_BssEnd
ldr r2, =0

b 2f
1: str r2, [r0], #4
2: cmp r0, r1
blo 1b

bl EnableClockGPIOA
bl EnableClockTIM1
bl ConfigurePA8

ldr r1, =GPIOx_BSRR_BS8
ldr r0, =GPIOA
str r1, [r0, #GPIOx_BSRR]

ldr r0, =TIM1_UP_IRQn
bl EnableIRQ
bl StartTIM1
1:
wfi
b 1b
.ltorg

.type TIM1_UP_IRQHandler, %function
.global TIM1_UP_IRQHandler
TIM1_UP_IRQHandler:
ldr r0, =TIM1
ldr r2, =(~(1 << TIMx_SR_UIF))

ldr r1, [r0, #TIMx_SR]
bics r1, r2
beq 2f

str r2, [r0, #TIMx_SR]

ldr r0, =BlinkStep

ldrb r1, [r0]

cmp r1, #(BlinkTableEnd-BlinkTable)
bhs 2f

ldr r0, =TimerEvents
ldrb r3, [r0]
subs r3, #1

itt ne
strbne r3, [r0]
bne 2f

add r1, #1
cmp r1, #(BlinkTableEnd-BlinkTable)
bhs 1f

ldr r2, =BlinkTable
ldrb r3, [r2, r1]
strb r3, [r0]

1:
ldr r0, =BlinkStep
strb r1, [r0]

ands r1, #1
ite eq
ldreq r1, =GPIOx_BSRR_BS8
ldrne r1, =GPIOx_BSRR_BR8

ldr r0, =GPIOA
str r1, [r0, #GPIOx_BSRR]

2:
bx lr

.align 2
.type BlinkTable,%object
BlinkTable:
.byte 2, 2, 2, 2, 2, 2
.byte 5, 2, 5, 2, 5, 2
.byte 2, 2, 2, 2, 2
BlinkTableEnd:

.align 2

.type EnableClockGPIOA, %function
EnableClockGPIOA:
ldr r1, =RCC
ldr r0, [r1, #RCC_APB2ENR]
orr r0, r0, #(1 << RCC_APB2ENR_IOPAEN)
str r0, [r1, #RCC_APB2ENR] @ Set IOPAEN bit in RCC_APB2ENR to 1 to enable GPIOA
bx lr @ Return to caller

.type EnableClockTIM1, %function
EnableClockTIM1:
ldr r1, =RCC
ldr r0, [r1, #RCC_APB2ENR]
orr r0, r0, #(1 << RCC_APB2ENR_TIM1EN)
str r0, [r1, #RCC_APB2ENR] @ Set TIM1EN bit in RCC_APB2ENR to 1 to enable TIM1
bx lr @ Return to caller
.ltorg

.type ConfigurePA8, %function
ConfigurePA8:
ldr r1, =GPIOA
ldr r0, [r1, #GPIOx_CRH]
and r0, #0xfffffff0
orr r0, #GPIOx_CRx_GP_PP_2MHz
str r0, [r1, #GPIOx_CRH] @ Set CNF8:MODE8 in GPIOA_CRH to 2
bx lr
.ltorg

@ r0 = Count-Down value for timer
.type InitializeSysTick, %function
StartTIM1:
ldr r0, =TIM1
ldr r1, =(1 << TIMx_CR1_URS)
str r1, [r0, #TIMx_CR1]

ldr r1, =TimerPrescaler
str r1, [r0, #TIMx_PSC]

ldr r1, =TimerValue
str r1, [r0, #TIMx_ARR]

ldr r1, =(1 << TIMx_DIER_UIE)
str r1, [r0, #TIMx_DIER]

ldr r1, =(1 << TIMx_EGR_UG)
str r1, [r0, #TIMx_EGR]

dsb

ldr r1, =(1 << TIMx_CR1_CEN)
str r1, [r0, #TIMx_CR1]

bx lr
.ltorg

@ r0 = IRQ Number
.type EnableIRQ, %function
EnableIRQ:
ldr r1, =NVIC_ISER0

movs r2, #1
and r3, r0, #0x1F
lsls r2, r2, r3

lsrs r3, r0, #5
lsls r3, r3, #2

str r2, [r1, r3]

bx lr
.ltorg
</source>

The corresponding stm32f103.inc file with the added definitions for the timer registers is:

<source lang=asm>
GPIOA = 0x40010800

GPIOx_CRH = 0x4
GPIOx_BSRR = 0x10
GPIOx_BSRR_BS8 = 0x100
GPIOx_BSRR_BR8 = 0x1000000

GPIOx_CRx_GP_PP_2MHz = 2

SCS = 0xe000e000
SCS_SYST_CSR = 0x10
SCS_SYST_RVR = 0x14
SCS_SYST_CVR = 0x18

RCC = 0x40021000
RCC_APB2ENR = 0x18
RCC_APB2ENR_IOPAEN = 2
RCC_APB2ENR_TIM1EN = 11

RCC_CR = 0x0
RCC_CR_PLLRDY = 25
RCC_CR_PLLON = 24
RCC_CR_HSERDY = 17
RCC_CR_HSEON = 16
RCC_CR_HSION = 0

RCC_CFGR = 0x04
RCC_CFGR_PLLMUL = 18
RCC_CFGR_USBPRE = 22
RCC_CFGR_PLLXTPRE = 17
RCC_CFGR_PLLSRC = 16
RCC_CFGR_PPRE2 = 11
RCC_CFGR_PPRE1 = 8
RCC_CFGR_HPRE = 4
RCC_CFGR_SWS = 2
RCC_CFGR_SW = 0

FLASH=0x40022000
FLASH_ACR=0
FLASH_ACR_PRFTBE = 4
FLASH_ACR_HLFCYA = 3
FLASH_ACR_LATENCY = 0

TIM1 = 0x40012C00

TIMx_CR1 = 0
TIMx_CR1_ARPE = 7
TIMx_CR1_URS = 2
TIMx_CR1_CEN = 0

TIMx_DIER = 0xC
TIMx_DIER_UIE = 0

TIMx_SR = 0x10
TIMx_SR_UIF = 0

TIMx_EGR = 0x14
TIMx_EGR_UG = 0

TIMx_PSC = 0x28
TIMx_ARR = 0x2C

TIM1_UP_IRQn = 25

NVIC_ISER0 = 0xE000E100
</source>

The source code enables the timer’s clock in the RCC before configuring it. The timer supports both a freely configurable prescaler for dividing the clock and a freely configurable maximum value, both of which are set by the StartTIM1 function. The TIMx_DIER_UIE bit is set to enable the interrupt for the so-called “update event”, which is triggered whenever the timer reaches the maximum value. A delicate sequence of register accesses is required to start the timer with the right configuration but without triggering the interrupt right away: To apply the modified settings immediately, the “TIMx_EGR_UG” bit is set to trigger an “artificial” update event. To prevent this from also triggering the interrupt, the “TIMx_CR1_URS” bit is set and cleared before and after, respectively. The timer is started by setting the “TIMx_CR1_CEN” bit at the end. Before that, a “dsb” instruction is inserted. This “Data Synchronization Barrier” waits until all write accesses before that have been completely processed - usually, the processors pipeline is working on several instructions at once. Because the timer configuration needs to be truly finished before starting the timer, this instruction is required. There are some other situations where the processor is too fast for the periphery and needs to be temporarily halted by a “dsb”. If some periphery-accessing code works in step-by-step mode while debugging, but not when executing normally, a well-placed “dsb” might help.

The ISR “TIM1_UP_IRQHandler” is used for the timer. It checks the “TIMx_SR_UIF” bit to verify an update event has actually happened. In that case, the register is overwritten with the value 0xFFFFFFFE, i.e. all bits are written with “1” except the UIF bit. Writing ones has no effect on the bits in this register, and writing a zero clears the respective bit. Therefore, this write access clears the UIF bit but keeps the others. These interrupt flags must always be cleared as soon as possible in the ISR, or the periphery might trigger the interrupt again immediately. The rest of the ISR stays the same.
=== Analysis tools ===
When working on a low level directly with linker scripts and assembly code, it is frequently necessary to directly verify the translation output, as you can’t rely on a compiler doing it right automatically, and flashing the program each time to see whether it works isn’t the most efficient way. This was, in fact, important in creating the example codes for this tutorial. The “binutils” package, of which assembler and linker are part of, offers a few tools that help with analyzing the assembler’s and linker’s output.
==== Disassembler ====
As the name implies, a disassembler is the opposite of an assembler - it turns binary machine code back into a (more or less) readable textual representation. If you feed an ELF file generated by the assembler or linker into the disassembler, it will read the header information to tell apart data (i.e. constants) and code, get names of symbols (and therefore, labels) and can even tell which instructions were generated from which assembly source file, if it was assembler with debug information (i.e. the “-g” flag was used). If you disassemble a binary flash image, the disassembler doesn’t have all those information and will produce a much less readable output and attempt to decode data bytes as instructions.

The disassembler from binutils is called “objdump”. Invoking it on the blinker looks like this:
<pre>
$ arm-none-eabi-objdump -d -s prog1.elf

prog1.elf: file format elf32-littlearm

Contents of section .VectorTable:
8000000 00040020 ed000008 ed010008 ed010008 ... ............
8000010 ed010008 ed010008 ed010008 00000000 ................
8000020 00000000 00000000 00000000 ed010008 ................
8000030 ed010008 00000000 ed010008 49010008 ............I...
8000040 ed010008 ed010008 ed010008 ed010008 ................
8000050 ed010008 ed010008 ed010008 ed010008 ................
8000060 ed010008 ed010008 ed010008 ed010008 ................
8000070 ed010008 ed010008 ed010008 ed010008 ................
8000080 ed010008 ed010008 ed010008 ed010008 ................
8000090 ed010008 ed010008 ed010008 ed010008 ................
80000a0 ed010008 ed010008 ed010008 ed010008 ................
80000b0 ed010008 ed010008 ed010008 ed010008 ................
80000c0 ed010008 ed010008 ed010008 ed010008 ................
80000d0 ed010008 ed010008 ed010008 ed010008 ................
80000e0 ed010008 ed010008 ed010008 ............
Contents of section .text:
80000ec 0f481049 104a03e0 52f8043b 40f8043b .H.I.J..R..;@..;
80000fc 8842f9d3 0d480e49 4ff00002 01e040f8 .B...H.IO.....@.
800010c 042b8842 fbd300f0 47f800f0 4bf84ff4 .+.B....G...K.O.
800011c 80710848 01600848 00f058f8 30bffde7 .q.H.`.H..X.0...
800012c 00040020 04040020 f0010008 04040020 ... ... .......
800013c 08040020 10080140 60e31600 4ff0e020 ... ...@`...O..
800014c 006910f4 803f1dd0 1a480178 b1f1110f .i...?...H.x....
800015c 18d21948 0378013b 1cbf0370 12e001f1 ...H.x.;...p....
800016c 0101b1f1 110f02d2 144a535c 03701148 .........JS\.p.H
800017c 017011f0 01010cbf 4ff48071 4ff08071 .p......O..qO..q
800018c 0f480160 70470202 02020202 05020502 .H.`pG..........
800019c 05020202 02020200 0a490868 40f00400 .........I.h@...
80001ac 08607047 08490868 20f00f00 40f00200 .`pG.I.h ...@...
80001bc 08607047 04040020 00040020 92010008 .`pG... ... ....
80001cc 10080140 18100240 04080140 4ff0e021 ...@...@...@O..!
80001dc 48614ff0 00008861 4ff00700 08617047 HaO....aO....apG
80001ec 00befde7 ....
Contents of section .data:
20000400 02000000 ....
Contents of section .ARM.attributes:
0000 41200000 00616561 62690001 16000000 A ...aeabi......
0010 05436f72 7465782d 4d330006 0a074d09 .Cortex-M3....M.
0020 02 .
Contents of section .debug_line:
0000 98000000 02001e00 00000201 fb0e0d00 ................
0010 01010101 00000001 00000100 70726f67 ............prog
0020 312e5300 00000000 000502ec 00000803 1.S.............
0030 15012121 22212f2f 21222121 30212f21 ..!!"!//!"!!0!/!
0040 222f302f 21232130 21036120 2f2f362f "/0/!#!0!.a //6/
0050 030c2e32 030a2e2f 212f2222 222f2221 ...2.../!/"""/"!
0060 21222121 222f2f22 21212321 222f212f !"!!"//"!!#!"/!/
0070 30212303 0d9e2121 2f212421 212f2f21 0!#...!!/!$!!//!
0080 03422035 030c2e03 0d2e0311 2e36030b .B 5.........6..
0090 2e30212f 222f2202 01000101 3b000000 .0!/"/".....;...
00a0 02002400 00000201 fb0e0d00 01010101 ..$.............
00b0 00000001 00000100 76656374 6f727461 ........vectorta
00c0 626c652e 53000000 00000005 02ec0100 ble.S...........
00d0 0803d000 01210201 000101 .....!.....
Contents of section .debug_info:
0000 22000000 02000000 00000401 00000000 "...............
0010 ec000008 ec010008 00000000 08000000 ................
0020 12000000 01802200 00000200 14000000 ......".........
0030 04019c00 0000ec01 0008f001 00082100 ..............!.
0040 00000800 00001200 00000180 ............
Contents of section .debug_abbrev:
0000 01110010 06110112 01030e1b 0e250e13 .............%..
0010 05000000 01110010 06110112 01030e1b ................
0020 0e250e13 05000000 .%......
Contents of section .debug_aranges:
0000 1c000000 02000000 00000400 00000000 ................
0010 ec000008 00010000 00000000 00000000 ................
0020 1c000000 02002600 00000400 00000000 ......&.........
0030 ec010008 04000000 00000000 00000000 ................
Contents of section .debug_str:
0000 70726f67 312e5300 2f746d70 2f746573 prog1.S./tmp/tes
0010 7400474e 55204153 20322e32 392e3531 t.GNU AS 2.29.51
0020 00766563 746f7274 61626c65 2e5300 .vectortable.S.

Disassembly of section .text:

080000ec <Reset_Handler>:
80000ec: 480f ldr r0, [pc, #60] ; (800012c <Reset_Handler+0x40>)
80000ee: 4910 ldr r1, [pc, #64] ; (8000130 <Reset_Handler+0x44>)
80000f0: 4a10 ldr r2, [pc, #64] ; (8000134 <Reset_Handler+0x48>)
80000f2: e003 b.n 80000fc <Reset_Handler+0x10>
80000f4: f852 3b04 ldr.w r3, [r2], #4
80000f8: f840 3b04 str.w r3, [r0], #4
80000fc: 4288 cmp r0, r1
80000fe: d3f9 bcc.n 80000f4 <Reset_Handler+0x8>
8000100: 480d ldr r0, [pc, #52] ; (8000138 <Reset_Handler+0x4c>)
8000102: 490e ldr r1, [pc, #56] ; (800013c <Reset_Handler+0x50>)
8000104: f04f 0200 mov.w r2, #0
8000108: e001 b.n 800010e <Reset_Handler+0x22>
800010a: f840 2b04 str.w r2, [r0], #4
800010e: 4288 cmp r0, r1
8000110: d3fb bcc.n 800010a <Reset_Handler+0x1e>
8000112: f000 f847 bl 80001a4 <EnableClockGPIOA>
8000116: f000 f84b bl 80001b0 <ConfigurePA8>
800011a: f44f 7180 mov.w r1, #256 ; 0x100
800011e: 4808 ldr r0, [pc, #32] ; (8000140 <Reset_Handler+0x54>)
8000120: 6001 str r1, [r0, #0]
8000122: 4808 ldr r0, [pc, #32] ; (8000144 <Reset_Handler+0x58>)
8000124: f000 f858 bl 80001d8 <StartSysTick>
8000128: bf30 wfi
800012a: e7fd b.n 8000128 <Reset_Handler+0x3c>
800012c: 20000400 .word 0x20000400
8000130: 20000404 .word 0x20000404
8000134: 080001f0 .word 0x080001f0
8000138: 20000404 .word 0x20000404
800013c: 20000408 .word 0x20000408
8000140: 40010810 .word 0x40010810
8000144: 0016e360 .word 0x0016e360

08000148 <SysTick_Handler>:
8000148: f04f 20e0 mov.w r0, #3758153728 ; 0xe000e000
800014c: 6900 ldr r0, [r0, #16]
800014e: f410 3f80 tst.w r0, #65536 ; 0x10000
8000152: d01d beq.n 8000190 <SysTick_Handler+0x48>
8000154: 481a ldr r0, [pc, #104] ; (80001c0 <ConfigurePA8+0x10>)
8000156: 7801 ldrb r1, [r0, #0]
8000158: f1b1 0f11 cmp.w r1, #17
800015c: d218 bcs.n 8000190 <SysTick_Handler+0x48>
800015e: 4819 ldr r0, [pc, #100] ; (80001c4 <ConfigurePA8+0x14>)
8000160: 7803 ldrb r3, [r0, #0]
8000162: 3b01 subs r3, #1
8000164: bf1c itt ne
8000166: 7003 strbne r3, [r0, #0]
8000168: e012 bne.n 8000190 <SysTick_Handler+0x48>
800016a: f101 0101 add.w r1, r1, #1
800016e: f1b1 0f11 cmp.w r1, #17
8000172: d202 bcs.n 800017a <SysTick_Handler+0x32>
8000174: 4a14 ldr r2, [pc, #80] ; (80001c8 <ConfigurePA8+0x18>)
8000176: 5c53 ldrb r3, [r2, r1]
8000178: 7003 strb r3, [r0, #0]
800017a: 4811 ldr r0, [pc, #68] ; (80001c0 <ConfigurePA8+0x10>)
800017c: 7001 strb r1, [r0, #0]
800017e: f011 0101 ands.w r1, r1, #1
8000182: bf0c ite eq
8000184: f44f 7180 moveq.w r1, #256 ; 0x100
8000188: f04f 7180 movne.w r1, #16777216 ; 0x1000000
800018c: 480f ldr r0, [pc, #60] ; (80001cc <ConfigurePA8+0x1c>)
800018e: 6001 str r1, [r0, #0]
8000190: 4770 bx lr

08000192 <BlinkTable>:
8000192: 0202 0202 0202 0205 0205 0205 0202 0202 ................
80001a2: .

080001a3 <BlinkTableEnd>:
...

080001a4 <EnableClockGPIOA>:
80001a4: 490a ldr r1, [pc, #40] ; (80001d0 <ConfigurePA8+0x20>)
80001a6: 6808 ldr r0, [r1, #0]
80001a8: f040 0004 orr.w r0, r0, #4
80001ac: 6008 str r0, [r1, #0]
80001ae: 4770 bx lr

080001b0 <ConfigurePA8>:
80001b0: 4908 ldr r1, [pc, #32] ; (80001d4 <ConfigurePA8+0x24>)
80001b2: 6808 ldr r0, [r1, #0]
80001b4: f020 000f bic.w r0, r0, #15
80001b8: f040 0002 orr.w r0, r0, #2
80001bc: 6008 str r0, [r1, #0]
80001be: 4770 bx lr
80001c0: 20000404 .word 0x20000404
80001c4: 20000400 .word 0x20000400
80001c8: 08000192 .word 0x08000192
80001cc: 40010810 .word 0x40010810
80001d0: 40021018 .word 0x40021018
80001d4: 40010804 .word 0x40010804

080001d8 <StartSysTick>:
80001d8: f04f 21e0 mov.w r1, #3758153728 ; 0xe000e000
80001dc: 6148 str r0, [r1, #20]
80001de: f04f 0000 mov.w r0, #0
80001e2: 6188 str r0, [r1, #24]
80001e4: f04f 0007 mov.w r0, #7
80001e8: 6108 str r0, [r1, #16]
80001ea: 4770 bx lr

080001ec <Default_Handler>:
80001ec: be00 bkpt 0x0000
80001ee: e7fd b.n 80001ec <Default_Handler>
</pre>

This is a lot of information. The “-d” flag tells objdump to disassemble code sections, and the “-s” flag lets it output data sections. At first, it prints the contents of “.VectorTable”. Each line is prefixed with the address of where this data is found in memory. Then, the 32bit data blocks from the vector table are output. The disassembler prints the bytes in the order they appear in memory, which, since the Cortex-M3 uses little endian, is reversed - for example, the printed “ed000008” actually refers to the address “0x080000ed”, which is the address of the “Reset_Handler” with the lowest bit set to one, as it is a thumb function. Most of the addresses in the vector table reflect the address of the default handler, 0x080001ec, except for the zero-entries and the SysTick_Handler. The contents of the “.text” section is the hexadecimal representation of the machine code, and hardly readable. The “.data” section contains a single “two” - this is the “02” put into “TimerEvents”. The contents of “.ARM.attributes:” and the various “.debug” sections is not very interesting, as it does not end up on the controller, and is only read by the various analysis tools to provide nicer output.

After that comes the actual disassembly. This is a list of all the instructions in the code section. The list is grouped by the symbols found in the input file. For C Code, each symbol usually matches one function, so each block in the disassembly represents one C function. In assembly code, if you put non-local labels into a function, that function will be split into multiple blocks by the disassembler, making it harder to read - the main reason for using local labels. Each instruction is translated into one line inside the blocks. The first column is the address where that instruction is found. The next column contains the hexadecimal representation of the 2 or 4 bytes that make up the machine code of that instruction, i.e. the actual content of flash memory. After that comes a textual representation of that instruction, as inferred by the disassembler. If the instruction contains some number, the disassembler sometimes outputs a semicolon followed by some interpretation of that number. If the instruction employs PC-relative addressing, that interpretation will be the absolute address. As many instructions have multiple spellings, there can be discrepancies between the original code and the disassembly. The disassembler will also output data, such as the “BlinkTable” and the literal pools, as such. Using the “.type” directive is helpful in that case so that the disassembler does not attempt to interpret the data bytes as code.

objdump can also be used to disassembly raw binary files that can be obtained by reading back the flash memory of some controller. To do this, use this command line:

<source lang=sh>
$ arm-none-eabi-objdump -b binary -m arm -D prog1.bin -Mforce-thumb --adjust-vma=0x08000000
</source>

The address of the binary in flash memory is specified so that the printed instruction addresses are correct. However, as the disassembler can’t tell data and code apart, the result will be of limited use. If you have to analyze a binary without having an ELF file or the source code, a more sophisticated disassembler such as IDA Pro is helpful. If you have the code and only need the disassembler to identify potential problems with the project (esp. the linker script), objdump is usually sufficient.
==== readelf ====
The “readelf” program is a powerful utility that can read and output various information from ELF files. The most useful option is the “-S” flag, which lets readelf print a summary of the sections in the respective file, e.g.:

<pre>
$ arm-none-eabi-readelf -S prog1.elf
There are 15 section headers, starting at offset 0x11268:

Section Headers:
[Nr] Name Type Addr Off Size ES Flg Lk Inf Al
[ 0] NULL 00000000 000000 000000 00 0 0 0
[ 1] .VectorTable PROGBITS 08000000 010000 0000ec 00 A 0 0 1
[ 2] .text PROGBITS 080000ec 0100ec 000104 00 AX 0 0 4
[ 3] .stack NOBITS 20000000 020000 000400 00 WA 0 0 1
[ 4] .data PROGBITS 20000400 010400 000004 00 WA 0 0 1
[ 5] .bss NOBITS 20000404 010404 000004 00 WA 0 0 1
[ 6] .ARM.attributes ARM_ATTRIBUTES 00000000 010404 000021 00 0 0 1
[ 7] .debug_line PROGBITS 00000000 010425 0000db 00 0 0 1
[ 8] .debug_info PROGBITS 00000000 010500 00004c 00 0 0 1
[ 9] .debug_abbrev PROGBITS 00000000 01054c 000028 00 0 0 1
[10] .debug_aranges PROGBITS 00000000 010578 000040 00 0 0 8
[11] .debug_str PROGBITS 00000000 0105b8 00002f 01 MS 0 0 1
[12] .symtab SYMTAB 00000000 0105e8 0006a0 10 13 45 4
[13] .strtab STRTAB 00000000 010c88 000550 00 0 0 1
[14] .shstrtab STRTAB 00000000 0111d8 000090 00 0 0 1
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
L (link order), O (extra OS processing required), G (group), T (TLS),
C (compressed), x (unknown), o (OS specific), E (exclude),
y (purecode), p (processor specific)
</pre>

For each section, one line is output. The sections “.strtab”, “.shstrtab”, “.symtab” and “NULL” are an integral part of ELF and always present. The “.debug” sections are present if the source was assembled with the “-g” flag. The “.ARM.attributes” section defines for which ARM processor the contained code was translated. These sections don’t end up on the microcontroller. The remaining sections were defined in the linker script: “.VectorTable” contains the addresses of the exception handlers, “.text” contains the program code and constant data for flash memory, “.stack” the stack in RAM, “.data” contains variables in RAM and “.bss” contains zero-initialized variables in RAM. For these sections, the column “Type” contains either “PROGBITS” or “NOBITS” that tells you whether the section in the ELF file actually contains some data - this is only the case for “.VectorTable”, “.text” and “.data”. The sections “.bss” and “.stack” only reserve memory that is written at runtime, but the ELF file doesn’t contain data to be written in these sections. The column “Addr” defines where this section begins in the address space. The most useful column is “Size”: If you sum up the sizes of the sections “.VectorTable”, “.text” and “.data”, you can obtain the used flash memory. By summing ob “.data”, “.stack” and “.bss”, you get the used amount of RAM. Note that “.data” is counted twice, as the initialization data is stored in flash.
==== nm ====
The “nm” utility prints the symbols defined in an ELF file, for example:

<pre>
$ arm-none-eabi-nm prog1.elf
080001ec W ADC1_2_IRQHandler
20000404 b BlinkStep
08000192 t BlinkTable
080001a3 t BlinkTableEnd
20000408 B _BssEnd
20000404 B _BssStart
…
</pre>

This can be helpful in analyzing errors in linker scripts where symbols might get assigned wrong addresses.
==== addr2line ====
The “addr2line” utility reads the debug information from an ELF file to determine which line in which source file produced the instruction found at a particular given address. For example:

<source lang=sh>
$ arm-none-eabi-addr2line 0x080000f0 -e prog1.elf
/tmp/test/prog1.S:24
</source>

Here, line 24 of “prog1.S” contains the assembler command that produced the instruction that ends up at address 0x080000f0.

==== objcopy ====
The “objcopy” utility allows you to translate program files between different formats. It is useful to convert the ELF files to both the Intel Hex format and a simple binary representation. For example,

<source lang=sh>
arm-none-eabi-objcopy -O ihex prog1.elf prog1.hex
</source>

produces a “.hex” file that contains an image of the flash contents in hexadecimal form. With

<source lang=sh>
arm-none-eabi-objcopy -O binary prog1.elf prog1.bin
</source>

a binary file is createed which contains an exact 1:1 image of the flash contents. Some flashing tools require these formats instead of ELF, and viewing the binary file with a hex editor can be interesting as well.

=== Interfacing C and C++ code ===
Since assembly is rarely used to implement entire complex projects, but mostly for few time-critical or especially low-level routines that are part of larger code bases written in a high-level-language, interfacing C and assembly code is an important topic, which will be covered here. While it is possible to write the main project structure in assembly and integrate some C modules, it is usually done the other way round. Most of the code shown is already ready to be included in C programs. Most of this topic works the same way for C++, apart from C++ exceptions (not to be confused with ARM processor exceptions) - but these are rarely used on embedded targets anyways.

If you compile C, C++ and assembly code into individual .o object files, you can link these together using “ld” as before. However, C and C++ code usually requires access to the respective standard library, and “ld” doesn’t link these by default - therefore it is neccessary to substitute “ld” for a call to “gcc” or “g++” for C or C++, respectively. This will call “ld” internally and pass the required libraries.
==== Environment setup for C and C++ ====
Many C projects use a reset handler and vector table implemented in assembly, although writing them in C is possible too. As required by the C standard, C programs start with the “main()” function, so the (assembly) reset handler should setup the environment such that it is ready for C, and then call “main”. The C code might then later call some assembly functions or inline assembly. When using C++ code, or some GCC extension for C code, it is required to call some additional functions before calling “main”. This is used by C++ to call the constructors of global objects. The C and C++ compilers emit a table of function pointers to functions that should be called at startup. This table has to be put into flash memory by modifying the linker script as follows:

<source>
.text : {
*(.text)
. = ALIGN(4);

_InitArrayStart = .;
*(SORT(.preinit_array*))
*(SORT(.init_array*))
_InitArrayEnd = .;
} >FLASH
</source>

The table of function pointers is sorted to keep the order needed by the compiler. The symbols “_InitArrayStart” and “_InitArrayEnd” mark beginning and end of that table. A reset handler that performs the memory initialization as before and calls the table of initialization functions could look like this:

<source lang=asm>
.syntax unified
.cpu cortex-m3
.thumb

.text
.type Reset_Handler, %function
.global Reset_Handler
Reset_Handler:
ldr r0, =_DataStart
ldr r1, =_DataEnd
ldr r2, =_DataLoad

b 2f
1: ldr r3, [r2], #4
str r3, [r0], #4
2: cmp r0, r1
blo 1b

ldr r0, =_BssStart
ldr r1, =_BssEnd
ldr r2, =0

b 2f
1: str r2, [r0], #4
2: cmp r0, r1
blo 1b

ldr r4, =_InitArrayStart
ldr r5, =_InitArrayEnd

b 2f
1: ldr r0, [r4], #4
blx r0
2: cmp r4, r5
blo 1b

bl main
1: bkpt
b 1b
.ltorg
</source>

Note that for iterating the table, registers r4 and r5 are used, since the called functions may not overwrite those. The “blx” instruction is needed to perform the indirect function call. When everything is set up, the main function is called. For embedded programs, the main function should never return (i.e. contain an endless loop). If it does, that’s an error, and to make it easier to find, an endless loop with a forced breakpoint is put right after the call to “main”.
==== Calling functions ====
To call assembly functions from C code and vice-versa, the assembly functions should observe the calling convention, as mentioned before. C functions can be called just like assembly functions from assembly code, by placing the parameters in register r0-r3 and on the stack, calling the function using “bl” and retrieving the return value from r0. To call an assembly function from C code, you need to declare it in C first just like a C function. For example, to call a function that takes 2 integer arguments and returns an integer:

<source lang=c>
int AssemblyFunction (int a, int b);
</source>

If you now define a function named “AssemblyFunction” in your assembly code and export it via “.global”, you can call it from C code just like any function.
==== Accessing global variables ====
Global variables defined in C can be accessed from assembly code just like variables defined in assembly code, by using the variable’s name. To access an assembly variable from C code, you need to declare it first by specifying the type. For example, to declare an integer variable:

<source lang=c>
extern int AssemblyVariable;
</source>

If you now define a variable named “AssemblyVariable” in your assembly code and export it via “.global”, you can access it from C code just like any variable. The “extern” is required to make sure the C code doesn’t attempt to declare another variable of the same name.
=== Clock configuration ===
By default, STM32 controllers use an internal RC-oscillator with 8 MHz as a clock source for the core and periphery. This oscillator is too inaccurate for implementing a clock or using serial interfaces such as UART, USB or CAN. To obtain a more accurate clock, an external quartz crystal is usually applied. Many STM32 boards feature an 8 MHz crystal. To use it, some initialization code is required that activates the microcontroller’s built-in crystal-oscillator circuit and switches the clock input to that. The STM32 controllers also include a PLL which can multiply some input clock by a configurable factor before feeding it to the processor core and peripherals. This way, a precise and fast clock can be achieved - the STM32F103 supports up to 72 MHz core frequency. Unfortunately, flash memory is not capable of keeping up with such a high frequency. Therefore, when enabling a fast clock, the flash memory needs to be configured to use wait states depending on the frequency.

The following function configures the flash wait states, enables the crystal oscillator, configures the PLL to multiply the input clock by a factor of 9, and use that as the system clock. The prescaler for the internal bus APB1 is set to 2. Assuming an 8 MHz crystal, this achieves the maximum performance possible with this microcontroller - 72 MHz for the core and APB2 domain, 36 MHz for APB1. If a different crystal is used, the PLL factors have to be adjusted.

<source lang=asm>
RCC = 0x40021000

RCC_CR = 0x0
RCC_CR_PLLRDY = 25
RCC_CR_PLLON = 24
RCC_CR_HSERDY = 17
RCC_CR_HSEON = 16
RCC_CR_HSION = 0

RCC_CFGR = 0x04
RCC_CFGR_PLLMUL = 18
RCC_CFGR_USBPRE = 22
RCC_CFGR_PLLXTPRE = 17
RCC_CFGR_PLLSRC = 16
RCC_CFGR_PPRE2 = 11
RCC_CFGR_PPRE1 = 8
RCC_CFGR_HPRE = 4
RCC_CFGR_SWS = 2
RCC_CFGR_SW = 0

FLASH=0x40022000
FLASH_ACR=0
FLASH_ACR_PRFTBE = 4
FLASH_ACR_HLFCYA = 3
FLASH_ACR_LATENCY = 0

.type ConfigureSysClock, %function
.global ConfigureSysClock
ConfigureSysClock:
@ Turn on HSE
ldr r0, =RCC
ldr r1, =((1 << RCC_CR_HSION)|(1 << RCC_CR_HSEON))
str r1, [r0, #RCC_CR]

@ Configure (but not start yet) PLL
@ Mul = 9, Prediv = 1, APB1 Prescaler = 2, APB2 Prescaler = 1, AHB Prescaler = 1
ldr r2, =(((9-2)<<RCC_CFGR_PLLMUL)|(1 << RCC_CFGR_USBPRE)|(1 << RCC_CFGR_PLLSRC)|(4 << RCC_CFGR_PPRE1))
str r2, [r0, #RCC_CFGR]

@ Pre-Calculate value for RCC_CR
orr r1, #(1 << RCC_CR_PLLON)

@ Wait for HSE ready
1: ldr r3, [r0, #RCC_CR]
ands r3, #(1 << RCC_CR_HSERDY)
beq 1b

@ Turn on PLL
str r1, [r0, #RCC_CR]

@ Pre-Calculate value for RCC_CFGR
orr r2, #(2 << RCC_CFGR_SW)

@ Wait for PLL ready
1: ldr r3, [r0, #RCC_CR]
ands r3, #(1 << RCC_CR_PLLRDY)
beq 1b

@ Set flash wait states to 2
ldr r0, =FLASH
ldr r3, =((1<<FLASH_ACR_PRFTBE)|(2<<FLASH_ACR_LATENCY))
str r3, [r0, #FLASH_ACR]
ldr r0, =RCC

@ Switch system clock to PLL
str r2, [r0, #RCC_CFGR]

@ Pre-Calculate value for RCC_CR
bic r1, #(1 << RCC_CR_HSION)

@ Wait for switch to PLL
1: ldr r3, [r0, #RCC_CFGR]
and r3, #(3 << RCC_CFGR_SWS)
cmp r3, #(2 << RCC_CFGR_SWS)
bne 1b

@ Turn off HSI to save power
str r1, [r0, #RCC_CR]

bx lr
.ltorg
</source>

Many projects perform the clock configuration by the reset handler before calling the main function. If you want to follow that practice, place a “bl ConfigureSysClock” as the first instruction in the “Reset_Handler” - this way, all the setup will run with the higher clock frequency, making start-up faster. This and the completed startup code from the previous chapters is implemented in the “startup.S” file in the example repository. If you use it, put your code in the “main” function, where RAM and system clock will already be initialized. This is shown in the “BlinkStartup” example.

=== Project template & makefile ===
To quickly start your own project, a project template is supplied in the examples repository under the directory [https://github.com/Erlkoenig90/ArmAsmTutorial/tree/master/ProjectTemplate-STM32F103RB ProjectTemplate-STM32F103RB]. Put your own application code in the program.S file. The startup.S and vectortable.S contain the reset handler with RAM initialization and the vector table with default handler, respectively. A linker script is included too.

The project also contains a makefile. This allows you to quickly translate your project without having to type the assembler and linker commands. Simply type
<source lang=sh>
make
</source>
To translate the code and produce program.elf, program.bin and program.hex files. All “.S” files in the directory will be automatically translated. Writing makefiles is a complex topic on its own with a lot of information already available on the web, so no further explanations on that will be made here.

Bitmanipulation

2015-07-27T19:41:21Z

Mthomas: /* AVR-Assembler */

== Bitoperatoren ==

Bitoperatoren stammen ursprünglich aus dem Bereich des Maschinen-Codes und Assembler, existieren aber auch in den meisten Hochsprachen, wie C.

* >> = Rechts schieben
* << = Links schieben (Bsp: ''a<<b'' ist das gleiche wie ''a * 2^b''; bzw. bei 1<<3 wird die 1 um drei Stellen nach links geschoben)
* | = binäres ODER
* & = binäres UND
* ^ = binäres Exklusives ODER
* usw.

Bitoperatoren in dieser Schreibweise können in Assemblercode für
konstante Ausdrücke benutzt werden.

Beispiel:

<syntaxhighlight lang="asm">
ldi temp, (1<<3) | (1<<1) | (1<<2) | (1<<0)
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 8 | 2 | 4 | 1
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 15
</syntaxhighlight>

== Bitmaske ==

Im Folgenden ist häufiger von dem Begriff ''Bitmaske'' die Rede. Damit wird eine Folge von einzelnen Bit bezeichnet, die den Zustand Null ('0') oder Eins ('1') darstellen können.

Bitmasken werden im allgemeinen dazu verwendet, um unter Anwendung eines Operators (z. B. UND, ODER, XOR), eine Eingabe zu manipulieren. Das Ergebnis ist dann die Anwendung des Operators auf die Eingabe und der Bitmaske.

Wenn ein Operator eine Funktion mit zwei Argumenten ist, dann lässt sich dessen Anwendung wie folgt schreiben:

<syntaxhighlight lang="c">
Ergebnis = Operator( Eingabe, Bitmaske )
</syntaxhighlight>

Die Bitmaske ist häufig eine Konstante, da diese z. B. die Information über die Position einer Information in einem Register darstellt. Das kann z. B. ein Überlaufflag in einem Timer Statusregister sein.

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="asm">
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</syntaxhighlight>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setze Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0; bitweises ODER

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</syntaxhighlight>

Die letzte Zeile "entschlüsselt":

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''|=''' : Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB wieder zugewiesen.

<syntaxhighlight lang="c">
PORTB |= variable; // Kurzschreibweise
PORTB = PORTB | variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend gemäss, den C-Regeln, die 1 als Integer Typ ansieht. Beim AVR-GCC bedeutet das 16-Bit/signed und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<syntaxhighlight lang="c">
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32; /* uint32_t definiert per typedef z. B. in stdint.h */
uint64_t reg_64; /* uint64_t definiert per typedef z. B. in stdint.h */

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1U << MEINBIT15); /* */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</syntaxhighlight>

Bei Compilern für 32bit Controller (z. B. ARM7TDMI) sind Integers per default 32-bit und Konstanten sind somit implizit ebenfalls 32-bit. Man sollte aber dennoch die oben gezeigte Vorgehenweise verwenden, um Probleme zu vermeiden die entstehen könnten, wenn Code unter verschiedenen Plattformen/Compilern verwendet werden soll.

== Bits löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="asm">
cbr r16, 0b00001111 ; löscht Bits 0-3 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden weil dieser Bereich nicht
; bitadressierbar ist
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, 1<<TOIE1
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, 1<<RXCIE0
sts UCSR0B, r16
</syntaxhighlight>

Auch hier gilt: Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 2 und 0" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-NOT-Verknüpfung (nicht zu verwechseln mit NAND), während der Befehl '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation << erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0; bitweises UND
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</syntaxhighlight>

Die letzte Zeile entschlüsselt:

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''~''' : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
# '''&=''' : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.

<syntaxhighlight lang="c">
PORTB &= variable; // Kurzschreibweise
PORTB = PORTB & variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111111, dann ist der Inhalt nach der Operation 0b01111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits 0 und 2 sind somit gelöscht.

Die C-Ausdrücke mittels Definitionen von Bitnummern und Schieboperator (<<) sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind deutlicher und nachvollziehbarer als "handoptimierte" Konstanten. Bei eingeschalteter Optimierung löst der Compiler die Ausdücke mit konstanten Werten bereits zur Compilierungszeit auf und es entsteht kein zusätzlicher Maschinencode. Bei AVR sind die Definitionen meist Teil der Entwicklungsumgebungen (bei avr-libc z. B. implizit durch #include <avr/io.h>). Sie entsprechen den Angaben und Beispielen in den Datenblättern und sind damit de-facto ein Standard beim Zugriff auf Bits in Hardware-Registern.

'''Wichtiger Hinweis''': Die ODER-Verknüpfung und die anschliessende Invertierung kann man nicht vertauschen! (Theorem von DeMorgan) Folgendes Beispiel soll die Richtigkeit der Aussage zeigen:

<syntaxhighlight lang="c">
~(0b0001 | 0b0010) == 0b1100
~0b0001 | ~0b0010 == 0b1111
</syntaxhighlight>

'''Noch ein wichtiger Hinweis''': Der operator ~ mit einem Operanden vom Typ int negiert nur so viele bits, wie der Typ int hat.
Will man ein bit in einer breiteren Variablen löschen, dann sollte die nach links zu shiftende 1 den Typ dieser Variablen haben.

Ein Programm, welches das verdeutlicht:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdint.h>

int main(int argc, const char* argv[])
{
int bit = 60;
uint64_t ui64;
printf("sizeof(int)=%d\n", (int)sizeof(int));

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<60); /* Keine Wirkung bei sizeof(int) < 8 */
/* gcc warnt sogar:
* gcc -Wall bit_clear.c -o bit_clear
* bit_clear.c: In function ‘main’:
* bit_clear.c:11:5: warning: left shift count >= width of type [enabled by default]
*/
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~((uint64_t)1<<60); /* ok */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1LL<<60); /* auch ok, und kürzer. */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<bit); /* Ohne Warnung, und funktioniert manchmal, je nach Optimierung */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

return 0;
}
/* Ausgabe auf meinem PC ohne Optimierung:
* sizeof(int)=4
* 0
* 1
* 1
* 1
* Ausgabe auf meinem PC mit -O2
* 0
* 1
* 1
* 0
*/
</syntaxhighlight>

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<syntaxhighlight lang="c">
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="c">
Byte : 01101000
Byte-1: 01100111
Ergebnis:01100000

</syntaxhighlight>
Das funktioniert also mit jeder beliebigen Zahl.

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<syntaxhighlight lang="c">
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = ~par;
}
return par;
}
</syntaxhighlight>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bits invertieren ==

Im allgemeinen Sprachgebrauch oft Toggeln genannt (aus dem Englischen). Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies folgender Assemblercode. Hier wird ein Ausgangspin invertiert.

<syntaxhighlight lang="asm">
sbic PortB, 0 ; Überspringe den nächsten Befehl, wenn das Bit 0 im Port gelöscht ist
rjmp ClrBitNow ; Springe zu ClrBitNow
sbi PortB, 0 ; Setze Bit 0 in PortB
rjmp BitReady ; Springe BitReady
ClrBitNow:
cbi PortB, 0 ; Lösche Bit 0 in PortB
BitReady:
</syntaxhighlight>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln. Diese Methode ist natürlich auch auf normale Daten anwendbar, nicht nur auf IO-Ports.

<syntaxhighlight lang="asm">
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit #2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</syntaxhighlight>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<syntaxhighlight lang="asm">
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</syntaxhighlight>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z. B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<syntaxhighlight lang="asm">
sbi PIND, 2 ; Bit 2 von Port D togglen
</syntaxhighlight>

=== 8051er ===

<syntaxhighlight lang="asm">
cpl bitadresse
</syntaxhighlight>

== Bits prüfen ==

Will man prüfen ob ein oder mehrere Bits in einer Variable gesetzt oder gelöscht sind, muss man sie mit einer Bitmaske UND verknüpfen. Die Bitmaske muss an den Stellen der zu prüfenden Bits eine '1' haben, an allen anderen eine '0'.

* Ist das Ergebnis gleich Null, sind alle geprüften Bits gelöscht.
* Ist das Ergebnis ungleich Null, ist mindestens ein geprüftes Bit gesetzt.
* Ist das Ergebnis gleich der Bitmaske, sind alle geprüften Bits gesetzt.

=== AVR Assembler ===

Der AVR hat spezielle Befehle um direkt einzelne Bits in den CPU-Registern r0..r31 sowie den IO-Registern 0..0x1F zu prüfen.

<syntaxhighlight lang="asm">
; Befehle zur Prüfung von einzelnen Bits

sbrs r16,3 ; überspringe den nächsten Befehl, wenn in r16 Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbrc r16,5 ; überspringe den nächsten Befehl, wenn in r16 Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

sbis timsk,3 ; überspringe den nächsten Befehl, wenn in timsk Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbic timsk,5 ; überspringe den nächsten Befehl, wenn in timsk Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

; Befehle zur Prüfung von mehreren Bits

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
breq alle_bits_sind_geloescht

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
brne mind_ein_bit_ist_gesetzt

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
cpi r16,0b1010
breq alle_bits_sind_gesetzt
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
// prüfe ob Bit 4 in der Variable tmp gelöscht ist
// die Klammer ist wichtig
if (!(tmp & 0x10)) {
// hier die Anweisungen, wenn das Bit gelöscht ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0) {
// hier die Anweisungen, wenn beide Bits gelöscht sind
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gesetzt ist
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gelöscht sind
if (~tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gelöscht ist
}

// prüfe ob Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x10) {
// hier die Anweisungen, wenn das Bit gesetzt ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gesetzt sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0x11) {
// hier die Anweisungen, wenn beide Bits gesetzt sind
}
</syntaxhighlight>

== Hilfsfunktionen zur Bitmanipulation in C/C++ ==
Um "einfacher" elementare Bitmanipulationen durchzuführen bietet es sich an einige Hilfsfunktionen zu definieren. Dabei gibt es zwei verschiedene Möglichkeiten diese zu realiseren:
* Als C-Makro [[C_Makros]]
* Als Inline-Funktion
In beiden Fällen wird bei eingeschalteter Optimierung letztendlich vom Compiler ein sehr kompakter (und identischer!) Code erzeugt, jedoch ist dringend von der Verwendung von Makros abzuraten (siehe [[Makro]] )!
Im Fehlerfall zeigt der Compiler bei der Verwendung vom Makros keine eindeutigen Fehlermeldungen an, da es sich um simple Ersetzungen handelt - bei der Verwendung von Inline-Funktionen hingegen gibt es eine "brauchbare" Fehlermeldung!

=== Beispiele - Inline Variante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen über Pointer
// PORTA, PB2 setzen
BIT_SET(&PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(&PORTC, PB0);

// PORTA, PB2 direkt setzen
// HIGH
BIT_BOOL_SET(&PORTA, PB2, 1);

// LOW
BIT_BOOL_SET(&PORTA, PB2, 0);
</syntaxhighlight>

=== Beispiele - MakroVariante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen direkt über die Variablen/Portnamen
// PORTA, PB2 setzen
BIT_SET(PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(PORTC, PB0);
</syntaxhighlight>

Um die Hilfsfunktionen verwenden zu können einfach folgenden Code in eine neue Header-Datei (z.B. BitIO.h) kopieren:

=== Hilfsfunktionen als Inline-Methoden ===
Achtung: Wenn nur ein C Compiler verwendet wird, kennt dieser den Typ "bool" nicht, dieser muss dann vorher definiert werden!
<syntaxhighlight lang="c">
/**
* BitIO.h
* @author Andi Dittrich <http://andidittrich.de>
* @version 1.0
* @license MIT Style X11 License
*/

#include <inttypes.h>

#ifndef BITIO_H_
#define BITIO_H_

// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
*target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
*target &= ~(1<<bit);
};

// bit toogle
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit){
*target ^= (1<<bit);
};

// set bit by boolean
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable) __attribute__((always_inline));
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable){
if (enable){
BIT_SET(target, bit);
}else{
BIT_CLEAR(target, bit);
}
};

#endif /* BITIO_H_ */

</syntaxhighlight>

=== Hilfsfunktionen als C-Makro (nicht empfohlen) ===
<syntaxhighlight lang="c">
/* Bit setzen */
#define set_bit(var, bit) ((var) |= (1 << (bit)))

/* Bit löschen */
#define clear_bit(var, bit) ((var) &= (unsigned)~(1 << (bit)))

/* Bit togglen */
#define toggle_bit(var,bit) ((var) ^= (1 << (bit)))
</syntaxhighlight>

== Bitmanipulation beim MSP430 ==

Beim MSP430 und dessen Compilern sind die Bitnamen meist anders definiert. Und zwar nicht als Bitnummer, sondern als Bitmuster. Darum schreibt man dort die Bitzugriffe in C anders. Das kann auch bei anderen Mikrocontrollern bzw. C-Compilern so sein. Wichtig ist, dass man seine eignen Definitionen in der gleichen Weise wie der Compiler anlegt, um Verwirrung zu vermeiden, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]

<syntaxhighlight lang="c">
// Definition von Bitnamen in den Headerfiles des Compilers

#define PD4 4 // Definition im AVR GCC als Bitnummer
#define PD5 5

#define P14 (1<<4) // Definition im MSP430 GCC als Bitmuster
#define P15 (1<<5)

// Bitmanipulation im Programm

DDRD = (1<<PD5) | (1<<PD4); // AVR GCC
P1DIR = P15 | P14; // MSP430 GCC
</syntaxhighlight>

==Siehe auch==

* [http://www.mikrocontroller.net/topic/179566#1729219 Forumsbeitrag:] Bits aus einem Array extrahieren
* [http://www.mikrocontroller.net/topic/169509#1631439 Forumsbeitrag:] Bits für ein Schieberegister zusammenstellen, TLC5941
* [http://www.mikrocontroller.net/topic/353071?goto=3947567#3947567 Forumsbeitrag:] TLC5947 und ATmega16 Bitmanipulation
* [http://www.mikrocontroller.net/topic/15466?goto=107726#107720 Forumsbeitrag:] Bitreihenfolge ändern
* [http://www.mikrocontroller.net/topic/23866?goto=new#177674 Forumsbeitrag:] Wie drehe ich eine Bitreihenfolge um?
* [http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html AVR Build-in Functions], spezielle Funktion im avr-gcc zur schnellen Bitvertauschung, engl.

[[Category:8051]]
[[Category:AVR-Arithmetik]]

Bitmanipulation

2015-07-27T19:41:01Z

Mthomas: /* AVR-Assembler */

== Bitoperatoren ==

Bitoperatoren stammen ursprünglich aus dem Bereich des Maschinen-Codes und Assembler, existieren aber auch in den meisten Hochsprachen, wie C.

* >> = Rechts schieben
* << = Links schieben (Bsp: ''a<<b'' ist das gleiche wie ''a * 2^b''; bzw. bei 1<<3 wird die 1 um drei Stellen nach links geschoben)
* | = binäres ODER
* & = binäres UND
* ^ = binäres Exklusives ODER
* usw.

Bitoperatoren in dieser Schreibweise können in Assemblercode für
konstante Ausdrücke benutzt werden.

Beispiel:

<syntaxhighlight lang="asm">
ldi temp, (1<<3) | (1<<1) | (1<<2) | (1<<0)
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 8 | 2 | 4 | 1
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 15
</syntaxhighlight>

== Bitmaske ==

Im Folgenden ist häufiger von dem Begriff ''Bitmaske'' die Rede. Damit wird eine Folge von einzelnen Bit bezeichnet, die den Zustand Null ('0') oder Eins ('1') darstellen können.

Bitmasken werden im allgemeinen dazu verwendet, um unter Anwendung eines Operators (z. B. UND, ODER, XOR), eine Eingabe zu manipulieren. Das Ergebnis ist dann die Anwendung des Operators auf die Eingabe und der Bitmaske.

Wenn ein Operator eine Funktion mit zwei Argumenten ist, dann lässt sich dessen Anwendung wie folgt schreiben:

<syntaxhighlight lang="c">
Ergebnis = Operator( Eingabe, Bitmaske )
</syntaxhighlight>

Die Bitmaske ist häufig eine Konstante, da diese z. B. die Information über die Position einer Information in einem Register darstellt. Das kann z. B. ein Überlaufflag in einem Timer Statusregister sein.

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</syntaxhighlight>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setze Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0; bitweises ODER

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</syntaxhighlight>

Die letzte Zeile "entschlüsselt":

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''|=''' : Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB wieder zugewiesen.

<syntaxhighlight lang="c">
PORTB |= variable; // Kurzschreibweise
PORTB = PORTB | variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend gemäss, den C-Regeln, die 1 als Integer Typ ansieht. Beim AVR-GCC bedeutet das 16-Bit/signed und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<syntaxhighlight lang="c">
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32; /* uint32_t definiert per typedef z. B. in stdint.h */
uint64_t reg_64; /* uint64_t definiert per typedef z. B. in stdint.h */

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1U << MEINBIT15); /* */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</syntaxhighlight>

Bei Compilern für 32bit Controller (z. B. ARM7TDMI) sind Integers per default 32-bit und Konstanten sind somit implizit ebenfalls 32-bit. Man sollte aber dennoch die oben gezeigte Vorgehenweise verwenden, um Probleme zu vermeiden die entstehen könnten, wenn Code unter verschiedenen Plattformen/Compilern verwendet werden soll.

== Bits löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="asm">
cbr r16, 0b00001111 ; löscht Bits 0-3 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden weil dieser Bereich nicht
; bitadressierbar ist
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, 1<<TOIE1
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, 1<<RXCIE0
sts UCSR0B, r16
</syntaxhighlight>

Auch hier gilt: Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 2 und 0" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-NOT-Verknüpfung (nicht zu verwechseln mit NAND), während der Befehl '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation << erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0; bitweises UND
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</syntaxhighlight>

Die letzte Zeile entschlüsselt:

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''~''' : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
# '''&=''' : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.

<syntaxhighlight lang="c">
PORTB &= variable; // Kurzschreibweise
PORTB = PORTB & variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111111, dann ist der Inhalt nach der Operation 0b01111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits 0 und 2 sind somit gelöscht.

Die C-Ausdrücke mittels Definitionen von Bitnummern und Schieboperator (<<) sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind deutlicher und nachvollziehbarer als "handoptimierte" Konstanten. Bei eingeschalteter Optimierung löst der Compiler die Ausdücke mit konstanten Werten bereits zur Compilierungszeit auf und es entsteht kein zusätzlicher Maschinencode. Bei AVR sind die Definitionen meist Teil der Entwicklungsumgebungen (bei avr-libc z. B. implizit durch #include <avr/io.h>). Sie entsprechen den Angaben und Beispielen in den Datenblättern und sind damit de-facto ein Standard beim Zugriff auf Bits in Hardware-Registern.

'''Wichtiger Hinweis''': Die ODER-Verknüpfung und die anschliessende Invertierung kann man nicht vertauschen! (Theorem von DeMorgan) Folgendes Beispiel soll die Richtigkeit der Aussage zeigen:

<syntaxhighlight lang="c">
~(0b0001 | 0b0010) == 0b1100
~0b0001 | ~0b0010 == 0b1111
</syntaxhighlight>

'''Noch ein wichtiger Hinweis''': Der operator ~ mit einem Operanden vom Typ int negiert nur so viele bits, wie der Typ int hat.
Will man ein bit in einer breiteren Variablen löschen, dann sollte die nach links zu shiftende 1 den Typ dieser Variablen haben.

Ein Programm, welches das verdeutlicht:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdint.h>

int main(int argc, const char* argv[])
{
int bit = 60;
uint64_t ui64;
printf("sizeof(int)=%d\n", (int)sizeof(int));

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<60); /* Keine Wirkung bei sizeof(int) < 8 */
/* gcc warnt sogar:
* gcc -Wall bit_clear.c -o bit_clear
* bit_clear.c: In function ‘main’:
* bit_clear.c:11:5: warning: left shift count >= width of type [enabled by default]
*/
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~((uint64_t)1<<60); /* ok */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1LL<<60); /* auch ok, und kürzer. */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<bit); /* Ohne Warnung, und funktioniert manchmal, je nach Optimierung */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

return 0;
}
/* Ausgabe auf meinem PC ohne Optimierung:
* sizeof(int)=4
* 0
* 1
* 1
* 1
* Ausgabe auf meinem PC mit -O2
* 0
* 1
* 1
* 0
*/
</syntaxhighlight>

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<syntaxhighlight lang="c">
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="c">
Byte : 01101000
Byte-1: 01100111
Ergebnis:01100000

</syntaxhighlight>
Das funktioniert also mit jeder beliebigen Zahl.

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<syntaxhighlight lang="c">
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = ~par;
}
return par;
}
</syntaxhighlight>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bits invertieren ==

Im allgemeinen Sprachgebrauch oft Toggeln genannt (aus dem Englischen). Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies folgender Assemblercode. Hier wird ein Ausgangspin invertiert.

<syntaxhighlight lang="asm">
sbic PortB, 0 ; Überspringe den nächsten Befehl, wenn das Bit 0 im Port gelöscht ist
rjmp ClrBitNow ; Springe zu ClrBitNow
sbi PortB, 0 ; Setze Bit 0 in PortB
rjmp BitReady ; Springe BitReady
ClrBitNow:
cbi PortB, 0 ; Lösche Bit 0 in PortB
BitReady:
</syntaxhighlight>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln. Diese Methode ist natürlich auch auf normale Daten anwendbar, nicht nur auf IO-Ports.

<syntaxhighlight lang="asm">
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit #2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</syntaxhighlight>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<syntaxhighlight lang="asm">
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</syntaxhighlight>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z. B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<syntaxhighlight lang="asm">
sbi PIND, 2 ; Bit 2 von Port D togglen
</syntaxhighlight>

=== 8051er ===

<syntaxhighlight lang="asm">
cpl bitadresse
</syntaxhighlight>

== Bits prüfen ==

Will man prüfen ob ein oder mehrere Bits in einer Variable gesetzt oder gelöscht sind, muss man sie mit einer Bitmaske UND verknüpfen. Die Bitmaske muss an den Stellen der zu prüfenden Bits eine '1' haben, an allen anderen eine '0'.

* Ist das Ergebnis gleich Null, sind alle geprüften Bits gelöscht.
* Ist das Ergebnis ungleich Null, ist mindestens ein geprüftes Bit gesetzt.
* Ist das Ergebnis gleich der Bitmaske, sind alle geprüften Bits gesetzt.

=== AVR Assembler ===

Der AVR hat spezielle Befehle um direkt einzelne Bits in den CPU-Registern r0..r31 sowie den IO-Registern 0..0x1F zu prüfen.

<syntaxhighlight lang="asm">
; Befehle zur Prüfung von einzelnen Bits

sbrs r16,3 ; überspringe den nächsten Befehl, wenn in r16 Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbrc r16,5 ; überspringe den nächsten Befehl, wenn in r16 Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

sbis timsk,3 ; überspringe den nächsten Befehl, wenn in timsk Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbic timsk,5 ; überspringe den nächsten Befehl, wenn in timsk Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

; Befehle zur Prüfung von mehreren Bits

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
breq alle_bits_sind_geloescht

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
brne mind_ein_bit_ist_gesetzt

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
cpi r16,0b1010
breq alle_bits_sind_gesetzt
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
// prüfe ob Bit 4 in der Variable tmp gelöscht ist
// die Klammer ist wichtig
if (!(tmp & 0x10)) {
// hier die Anweisungen, wenn das Bit gelöscht ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0) {
// hier die Anweisungen, wenn beide Bits gelöscht sind
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gesetzt ist
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gelöscht sind
if (~tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gelöscht ist
}

// prüfe ob Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x10) {
// hier die Anweisungen, wenn das Bit gesetzt ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gesetzt sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0x11) {
// hier die Anweisungen, wenn beide Bits gesetzt sind
}
</syntaxhighlight>

== Hilfsfunktionen zur Bitmanipulation in C/C++ ==
Um "einfacher" elementare Bitmanipulationen durchzuführen bietet es sich an einige Hilfsfunktionen zu definieren. Dabei gibt es zwei verschiedene Möglichkeiten diese zu realiseren:
* Als C-Makro [[C_Makros]]
* Als Inline-Funktion
In beiden Fällen wird bei eingeschalteter Optimierung letztendlich vom Compiler ein sehr kompakter (und identischer!) Code erzeugt, jedoch ist dringend von der Verwendung von Makros abzuraten (siehe [[Makro]] )!
Im Fehlerfall zeigt der Compiler bei der Verwendung vom Makros keine eindeutigen Fehlermeldungen an, da es sich um simple Ersetzungen handelt - bei der Verwendung von Inline-Funktionen hingegen gibt es eine "brauchbare" Fehlermeldung!

=== Beispiele - Inline Variante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen über Pointer
// PORTA, PB2 setzen
BIT_SET(&PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(&PORTC, PB0);

// PORTA, PB2 direkt setzen
// HIGH
BIT_BOOL_SET(&PORTA, PB2, 1);

// LOW
BIT_BOOL_SET(&PORTA, PB2, 0);
</syntaxhighlight>

=== Beispiele - MakroVariante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen direkt über die Variablen/Portnamen
// PORTA, PB2 setzen
BIT_SET(PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(PORTC, PB0);
</syntaxhighlight>

Um die Hilfsfunktionen verwenden zu können einfach folgenden Code in eine neue Header-Datei (z.B. BitIO.h) kopieren:

=== Hilfsfunktionen als Inline-Methoden ===
Achtung: Wenn nur ein C Compiler verwendet wird, kennt dieser den Typ "bool" nicht, dieser muss dann vorher definiert werden!
<syntaxhighlight lang="c">
/**
* BitIO.h
* @author Andi Dittrich <http://andidittrich.de>
* @version 1.0
* @license MIT Style X11 License
*/

#include <inttypes.h>

#ifndef BITIO_H_
#define BITIO_H_

// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
*target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
*target &= ~(1<<bit);
};

// bit toogle
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit){
*target ^= (1<<bit);
};

// set bit by boolean
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable) __attribute__((always_inline));
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable){
if (enable){
BIT_SET(target, bit);
}else{
BIT_CLEAR(target, bit);
}
};

#endif /* BITIO_H_ */

</syntaxhighlight>

=== Hilfsfunktionen als C-Makro (nicht empfohlen) ===
<syntaxhighlight lang="c">
/* Bit setzen */
#define set_bit(var, bit) ((var) |= (1 << (bit)))

/* Bit löschen */
#define clear_bit(var, bit) ((var) &= (unsigned)~(1 << (bit)))

/* Bit togglen */
#define toggle_bit(var,bit) ((var) ^= (1 << (bit)))
</syntaxhighlight>

== Bitmanipulation beim MSP430 ==

Beim MSP430 und dessen Compilern sind die Bitnamen meist anders definiert. Und zwar nicht als Bitnummer, sondern als Bitmuster. Darum schreibt man dort die Bitzugriffe in C anders. Das kann auch bei anderen Mikrocontrollern bzw. C-Compilern so sein. Wichtig ist, dass man seine eignen Definitionen in der gleichen Weise wie der Compiler anlegt, um Verwirrung zu vermeiden, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]

<syntaxhighlight lang="c">
// Definition von Bitnamen in den Headerfiles des Compilers

#define PD4 4 // Definition im AVR GCC als Bitnummer
#define PD5 5

#define P14 (1<<4) // Definition im MSP430 GCC als Bitmuster
#define P15 (1<<5)

// Bitmanipulation im Programm

DDRD = (1<<PD5) | (1<<PD4); // AVR GCC
P1DIR = P15 | P14; // MSP430 GCC
</syntaxhighlight>

==Siehe auch==

* [http://www.mikrocontroller.net/topic/179566#1729219 Forumsbeitrag:] Bits aus einem Array extrahieren
* [http://www.mikrocontroller.net/topic/169509#1631439 Forumsbeitrag:] Bits für ein Schieberegister zusammenstellen, TLC5941
* [http://www.mikrocontroller.net/topic/353071?goto=3947567#3947567 Forumsbeitrag:] TLC5947 und ATmega16 Bitmanipulation
* [http://www.mikrocontroller.net/topic/15466?goto=107726#107720 Forumsbeitrag:] Bitreihenfolge ändern
* [http://www.mikrocontroller.net/topic/23866?goto=new#177674 Forumsbeitrag:] Wie drehe ich eine Bitreihenfolge um?
* [http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html AVR Build-in Functions], spezielle Funktion im avr-gcc zur schnellen Bitvertauschung, engl.

[[Category:8051]]
[[Category:AVR-Arithmetik]]

Bitmanipulation

2015-07-27T19:40:39Z

Mthomas: /* AVR Assembler */

== Bitoperatoren ==

Bitoperatoren stammen ursprünglich aus dem Bereich des Maschinen-Codes und Assembler, existieren aber auch in den meisten Hochsprachen, wie C.

* >> = Rechts schieben
* << = Links schieben (Bsp: ''a<<b'' ist das gleiche wie ''a * 2^b''; bzw. bei 1<<3 wird die 1 um drei Stellen nach links geschoben)
* | = binäres ODER
* & = binäres UND
* ^ = binäres Exklusives ODER
* usw.

Bitoperatoren in dieser Schreibweise können in Assemblercode für
konstante Ausdrücke benutzt werden.

Beispiel:

<syntaxhighlight lang="asm">
ldi temp, (1<<3) | (1<<1) | (1<<2) | (1<<0)
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 8 | 2 | 4 | 1
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 15
</syntaxhighlight>

== Bitmaske ==

Im Folgenden ist häufiger von dem Begriff ''Bitmaske'' die Rede. Damit wird eine Folge von einzelnen Bit bezeichnet, die den Zustand Null ('0') oder Eins ('1') darstellen können.

Bitmasken werden im allgemeinen dazu verwendet, um unter Anwendung eines Operators (z. B. UND, ODER, XOR), eine Eingabe zu manipulieren. Das Ergebnis ist dann die Anwendung des Operators auf die Eingabe und der Bitmaske.

Wenn ein Operator eine Funktion mit zwei Argumenten ist, dann lässt sich dessen Anwendung wie folgt schreiben:

<syntaxhighlight lang="c">
Ergebnis = Operator( Eingabe, Bitmaske )
</syntaxhighlight>

Die Bitmaske ist häufig eine Konstante, da diese z. B. die Information über die Position einer Information in einem Register darstellt. Das kann z. B. ein Überlaufflag in einem Timer Statusregister sein.

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</syntaxhighlight>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setze Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0; bitweises ODER

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</syntaxhighlight>

Die letzte Zeile "entschlüsselt":

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''|=''' : Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB wieder zugewiesen.

<syntaxhighlight lang="c">
PORTB |= variable; // Kurzschreibweise
PORTB = PORTB | variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend gemäss, den C-Regeln, die 1 als Integer Typ ansieht. Beim AVR-GCC bedeutet das 16-Bit/signed und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<syntaxhighlight lang="c">
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32; /* uint32_t definiert per typedef z. B. in stdint.h */
uint64_t reg_64; /* uint64_t definiert per typedef z. B. in stdint.h */

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1U << MEINBIT15); /* */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</syntaxhighlight>

Bei Compilern für 32bit Controller (z. B. ARM7TDMI) sind Integers per default 32-bit und Konstanten sind somit implizit ebenfalls 32-bit. Man sollte aber dennoch die oben gezeigte Vorgehenweise verwenden, um Probleme zu vermeiden die entstehen könnten, wenn Code unter verschiedenen Plattformen/Compilern verwendet werden soll.

== Bits löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
cbr r16, 0b00001111 ; löscht Bits 0-3 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden weil dieser Bereich nicht
; bitadressierbar ist
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, 1<<TOIE1
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, 1<<RXCIE0
sts UCSR0B, r16
</syntaxhighlight>

Auch hier gilt: Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 2 und 0" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-NOT-Verknüpfung (nicht zu verwechseln mit NAND), während der Befehl '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation << erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0; bitweises UND
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</syntaxhighlight>

Die letzte Zeile entschlüsselt:

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''~''' : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
# '''&=''' : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.

<syntaxhighlight lang="c">
PORTB &= variable; // Kurzschreibweise
PORTB = PORTB & variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111111, dann ist der Inhalt nach der Operation 0b01111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits 0 und 2 sind somit gelöscht.

Die C-Ausdrücke mittels Definitionen von Bitnummern und Schieboperator (<<) sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind deutlicher und nachvollziehbarer als "handoptimierte" Konstanten. Bei eingeschalteter Optimierung löst der Compiler die Ausdücke mit konstanten Werten bereits zur Compilierungszeit auf und es entsteht kein zusätzlicher Maschinencode. Bei AVR sind die Definitionen meist Teil der Entwicklungsumgebungen (bei avr-libc z. B. implizit durch #include <avr/io.h>). Sie entsprechen den Angaben und Beispielen in den Datenblättern und sind damit de-facto ein Standard beim Zugriff auf Bits in Hardware-Registern.

'''Wichtiger Hinweis''': Die ODER-Verknüpfung und die anschliessende Invertierung kann man nicht vertauschen! (Theorem von DeMorgan) Folgendes Beispiel soll die Richtigkeit der Aussage zeigen:

<syntaxhighlight lang="c">
~(0b0001 | 0b0010) == 0b1100
~0b0001 | ~0b0010 == 0b1111
</syntaxhighlight>

'''Noch ein wichtiger Hinweis''': Der operator ~ mit einem Operanden vom Typ int negiert nur so viele bits, wie der Typ int hat.
Will man ein bit in einer breiteren Variablen löschen, dann sollte die nach links zu shiftende 1 den Typ dieser Variablen haben.

Ein Programm, welches das verdeutlicht:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdint.h>

int main(int argc, const char* argv[])
{
int bit = 60;
uint64_t ui64;
printf("sizeof(int)=%d\n", (int)sizeof(int));

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<60); /* Keine Wirkung bei sizeof(int) < 8 */
/* gcc warnt sogar:
* gcc -Wall bit_clear.c -o bit_clear
* bit_clear.c: In function ‘main’:
* bit_clear.c:11:5: warning: left shift count >= width of type [enabled by default]
*/
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~((uint64_t)1<<60); /* ok */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1LL<<60); /* auch ok, und kürzer. */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<bit); /* Ohne Warnung, und funktioniert manchmal, je nach Optimierung */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

return 0;
}
/* Ausgabe auf meinem PC ohne Optimierung:
* sizeof(int)=4
* 0
* 1
* 1
* 1
* Ausgabe auf meinem PC mit -O2
* 0
* 1
* 1
* 0
*/
</syntaxhighlight>

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<syntaxhighlight lang="c">
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="c">
Byte : 01101000
Byte-1: 01100111
Ergebnis:01100000

</syntaxhighlight>
Das funktioniert also mit jeder beliebigen Zahl.

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<syntaxhighlight lang="c">
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = ~par;
}
return par;
}
</syntaxhighlight>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bits invertieren ==

Im allgemeinen Sprachgebrauch oft Toggeln genannt (aus dem Englischen). Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies folgender Assemblercode. Hier wird ein Ausgangspin invertiert.

<syntaxhighlight lang="asm">
sbic PortB, 0 ; Überspringe den nächsten Befehl, wenn das Bit 0 im Port gelöscht ist
rjmp ClrBitNow ; Springe zu ClrBitNow
sbi PortB, 0 ; Setze Bit 0 in PortB
rjmp BitReady ; Springe BitReady
ClrBitNow:
cbi PortB, 0 ; Lösche Bit 0 in PortB
BitReady:
</syntaxhighlight>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln. Diese Methode ist natürlich auch auf normale Daten anwendbar, nicht nur auf IO-Ports.

<syntaxhighlight lang="asm">
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit #2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</syntaxhighlight>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<syntaxhighlight lang="asm">
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</syntaxhighlight>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z. B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<syntaxhighlight lang="asm">
sbi PIND, 2 ; Bit 2 von Port D togglen
</syntaxhighlight>

=== 8051er ===

<syntaxhighlight lang="asm">
cpl bitadresse
</syntaxhighlight>

== Bits prüfen ==

Will man prüfen ob ein oder mehrere Bits in einer Variable gesetzt oder gelöscht sind, muss man sie mit einer Bitmaske UND verknüpfen. Die Bitmaske muss an den Stellen der zu prüfenden Bits eine '1' haben, an allen anderen eine '0'.

* Ist das Ergebnis gleich Null, sind alle geprüften Bits gelöscht.
* Ist das Ergebnis ungleich Null, ist mindestens ein geprüftes Bit gesetzt.
* Ist das Ergebnis gleich der Bitmaske, sind alle geprüften Bits gesetzt.

=== AVR Assembler ===

Der AVR hat spezielle Befehle um direkt einzelne Bits in den CPU-Registern r0..r31 sowie den IO-Registern 0..0x1F zu prüfen.

<syntaxhighlight lang="asm">
; Befehle zur Prüfung von einzelnen Bits

sbrs r16,3 ; überspringe den nächsten Befehl, wenn in r16 Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbrc r16,5 ; überspringe den nächsten Befehl, wenn in r16 Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

sbis timsk,3 ; überspringe den nächsten Befehl, wenn in timsk Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbic timsk,5 ; überspringe den nächsten Befehl, wenn in timsk Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

; Befehle zur Prüfung von mehreren Bits

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
breq alle_bits_sind_geloescht

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
brne mind_ein_bit_ist_gesetzt

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
cpi r16,0b1010
breq alle_bits_sind_gesetzt
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
// prüfe ob Bit 4 in der Variable tmp gelöscht ist
// die Klammer ist wichtig
if (!(tmp & 0x10)) {
// hier die Anweisungen, wenn das Bit gelöscht ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0) {
// hier die Anweisungen, wenn beide Bits gelöscht sind
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gesetzt ist
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gelöscht sind
if (~tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gelöscht ist
}

// prüfe ob Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x10) {
// hier die Anweisungen, wenn das Bit gesetzt ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gesetzt sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0x11) {
// hier die Anweisungen, wenn beide Bits gesetzt sind
}
</syntaxhighlight>

== Hilfsfunktionen zur Bitmanipulation in C/C++ ==
Um "einfacher" elementare Bitmanipulationen durchzuführen bietet es sich an einige Hilfsfunktionen zu definieren. Dabei gibt es zwei verschiedene Möglichkeiten diese zu realiseren:
* Als C-Makro [[C_Makros]]
* Als Inline-Funktion
In beiden Fällen wird bei eingeschalteter Optimierung letztendlich vom Compiler ein sehr kompakter (und identischer!) Code erzeugt, jedoch ist dringend von der Verwendung von Makros abzuraten (siehe [[Makro]] )!
Im Fehlerfall zeigt der Compiler bei der Verwendung vom Makros keine eindeutigen Fehlermeldungen an, da es sich um simple Ersetzungen handelt - bei der Verwendung von Inline-Funktionen hingegen gibt es eine "brauchbare" Fehlermeldung!

=== Beispiele - Inline Variante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen über Pointer
// PORTA, PB2 setzen
BIT_SET(&PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(&PORTC, PB0);

// PORTA, PB2 direkt setzen
// HIGH
BIT_BOOL_SET(&PORTA, PB2, 1);

// LOW
BIT_BOOL_SET(&PORTA, PB2, 0);
</syntaxhighlight>

=== Beispiele - MakroVariante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen direkt über die Variablen/Portnamen
// PORTA, PB2 setzen
BIT_SET(PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(PORTC, PB0);
</syntaxhighlight>

Um die Hilfsfunktionen verwenden zu können einfach folgenden Code in eine neue Header-Datei (z.B. BitIO.h) kopieren:

=== Hilfsfunktionen als Inline-Methoden ===
Achtung: Wenn nur ein C Compiler verwendet wird, kennt dieser den Typ "bool" nicht, dieser muss dann vorher definiert werden!
<syntaxhighlight lang="c">
/**
* BitIO.h
* @author Andi Dittrich <http://andidittrich.de>
* @version 1.0
* @license MIT Style X11 License
*/

#include <inttypes.h>

#ifndef BITIO_H_
#define BITIO_H_

// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
*target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
*target &= ~(1<<bit);
};

// bit toogle
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit){
*target ^= (1<<bit);
};

// set bit by boolean
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable) __attribute__((always_inline));
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable){
if (enable){
BIT_SET(target, bit);
}else{
BIT_CLEAR(target, bit);
}
};

#endif /* BITIO_H_ */

</syntaxhighlight>

=== Hilfsfunktionen als C-Makro (nicht empfohlen) ===
<syntaxhighlight lang="c">
/* Bit setzen */
#define set_bit(var, bit) ((var) |= (1 << (bit)))

/* Bit löschen */
#define clear_bit(var, bit) ((var) &= (unsigned)~(1 << (bit)))

/* Bit togglen */
#define toggle_bit(var,bit) ((var) ^= (1 << (bit)))
</syntaxhighlight>

== Bitmanipulation beim MSP430 ==

Beim MSP430 und dessen Compilern sind die Bitnamen meist anders definiert. Und zwar nicht als Bitnummer, sondern als Bitmuster. Darum schreibt man dort die Bitzugriffe in C anders. Das kann auch bei anderen Mikrocontrollern bzw. C-Compilern so sein. Wichtig ist, dass man seine eignen Definitionen in der gleichen Weise wie der Compiler anlegt, um Verwirrung zu vermeiden, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]

<syntaxhighlight lang="c">
// Definition von Bitnamen in den Headerfiles des Compilers

#define PD4 4 // Definition im AVR GCC als Bitnummer
#define PD5 5

#define P14 (1<<4) // Definition im MSP430 GCC als Bitmuster
#define P15 (1<<5)

// Bitmanipulation im Programm

DDRD = (1<<PD5) | (1<<PD4); // AVR GCC
P1DIR = P15 | P14; // MSP430 GCC
</syntaxhighlight>

==Siehe auch==

* [http://www.mikrocontroller.net/topic/179566#1729219 Forumsbeitrag:] Bits aus einem Array extrahieren
* [http://www.mikrocontroller.net/topic/169509#1631439 Forumsbeitrag:] Bits für ein Schieberegister zusammenstellen, TLC5941
* [http://www.mikrocontroller.net/topic/353071?goto=3947567#3947567 Forumsbeitrag:] TLC5947 und ATmega16 Bitmanipulation
* [http://www.mikrocontroller.net/topic/15466?goto=107726#107720 Forumsbeitrag:] Bitreihenfolge ändern
* [http://www.mikrocontroller.net/topic/23866?goto=new#177674 Forumsbeitrag:] Wie drehe ich eine Bitreihenfolge um?
* [http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html AVR Build-in Functions], spezielle Funktion im avr-gcc zur schnellen Bitvertauschung, engl.

[[Category:8051]]
[[Category:AVR-Arithmetik]]

Bitmanipulation

2015-07-27T19:40:04Z

Mthomas: /* Neuere ATmegas */

== Bitoperatoren ==

Bitoperatoren stammen ursprünglich aus dem Bereich des Maschinen-Codes und Assembler, existieren aber auch in den meisten Hochsprachen, wie C.

* >> = Rechts schieben
* << = Links schieben (Bsp: ''a<<b'' ist das gleiche wie ''a * 2^b''; bzw. bei 1<<3 wird die 1 um drei Stellen nach links geschoben)
* | = binäres ODER
* & = binäres UND
* ^ = binäres Exklusives ODER
* usw.

Bitoperatoren in dieser Schreibweise können in Assemblercode für
konstante Ausdrücke benutzt werden.

Beispiel:

<syntaxhighlight lang="asm">
ldi temp, (1<<3) | (1<<1) | (1<<2) | (1<<0)
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 8 | 2 | 4 | 1
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 15
</syntaxhighlight>

== Bitmaske ==

Im Folgenden ist häufiger von dem Begriff ''Bitmaske'' die Rede. Damit wird eine Folge von einzelnen Bit bezeichnet, die den Zustand Null ('0') oder Eins ('1') darstellen können.

Bitmasken werden im allgemeinen dazu verwendet, um unter Anwendung eines Operators (z. B. UND, ODER, XOR), eine Eingabe zu manipulieren. Das Ergebnis ist dann die Anwendung des Operators auf die Eingabe und der Bitmaske.

Wenn ein Operator eine Funktion mit zwei Argumenten ist, dann lässt sich dessen Anwendung wie folgt schreiben:

<syntaxhighlight lang="c">
Ergebnis = Operator( Eingabe, Bitmaske )
</syntaxhighlight>

Die Bitmaske ist häufig eine Konstante, da diese z. B. die Information über die Position einer Information in einem Register darstellt. Das kann z. B. ein Überlaufflag in einem Timer Statusregister sein.

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</syntaxhighlight>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setze Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0; bitweises ODER

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</syntaxhighlight>

Die letzte Zeile "entschlüsselt":

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''|=''' : Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB wieder zugewiesen.

<syntaxhighlight lang="c">
PORTB |= variable; // Kurzschreibweise
PORTB = PORTB | variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend gemäss, den C-Regeln, die 1 als Integer Typ ansieht. Beim AVR-GCC bedeutet das 16-Bit/signed und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<syntaxhighlight lang="c">
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32; /* uint32_t definiert per typedef z. B. in stdint.h */
uint64_t reg_64; /* uint64_t definiert per typedef z. B. in stdint.h */

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1U << MEINBIT15); /* */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</syntaxhighlight>

Bei Compilern für 32bit Controller (z. B. ARM7TDMI) sind Integers per default 32-bit und Konstanten sind somit implizit ebenfalls 32-bit. Man sollte aber dennoch die oben gezeigte Vorgehenweise verwenden, um Probleme zu vermeiden die entstehen könnten, wenn Code unter verschiedenen Plattformen/Compilern verwendet werden soll.

== Bits löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
cbr r16, 0b00001111 ; löscht Bits 0-3 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden weil dieser Bereich nicht
; bitadressierbar ist
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, 1<<TOIE1
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, 1<<RXCIE0
sts UCSR0B, r16
</syntaxhighlight>

Auch hier gilt: Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 2 und 0" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-NOT-Verknüpfung (nicht zu verwechseln mit NAND), während der Befehl '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation << erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0; bitweises UND
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</syntaxhighlight>

Die letzte Zeile entschlüsselt:

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''~''' : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
# '''&=''' : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.

<syntaxhighlight lang="c">
PORTB &= variable; // Kurzschreibweise
PORTB = PORTB & variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111111, dann ist der Inhalt nach der Operation 0b01111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits 0 und 2 sind somit gelöscht.

Die C-Ausdrücke mittels Definitionen von Bitnummern und Schieboperator (<<) sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind deutlicher und nachvollziehbarer als "handoptimierte" Konstanten. Bei eingeschalteter Optimierung löst der Compiler die Ausdücke mit konstanten Werten bereits zur Compilierungszeit auf und es entsteht kein zusätzlicher Maschinencode. Bei AVR sind die Definitionen meist Teil der Entwicklungsumgebungen (bei avr-libc z. B. implizit durch #include <avr/io.h>). Sie entsprechen den Angaben und Beispielen in den Datenblättern und sind damit de-facto ein Standard beim Zugriff auf Bits in Hardware-Registern.

'''Wichtiger Hinweis''': Die ODER-Verknüpfung und die anschliessende Invertierung kann man nicht vertauschen! (Theorem von DeMorgan) Folgendes Beispiel soll die Richtigkeit der Aussage zeigen:

<syntaxhighlight lang="c">
~(0b0001 | 0b0010) == 0b1100
~0b0001 | ~0b0010 == 0b1111
</syntaxhighlight>

'''Noch ein wichtiger Hinweis''': Der operator ~ mit einem Operanden vom Typ int negiert nur so viele bits, wie der Typ int hat.
Will man ein bit in einer breiteren Variablen löschen, dann sollte die nach links zu shiftende 1 den Typ dieser Variablen haben.

Ein Programm, welches das verdeutlicht:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdint.h>

int main(int argc, const char* argv[])
{
int bit = 60;
uint64_t ui64;
printf("sizeof(int)=%d\n", (int)sizeof(int));

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<60); /* Keine Wirkung bei sizeof(int) < 8 */
/* gcc warnt sogar:
* gcc -Wall bit_clear.c -o bit_clear
* bit_clear.c: In function ‘main’:
* bit_clear.c:11:5: warning: left shift count >= width of type [enabled by default]
*/
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~((uint64_t)1<<60); /* ok */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1LL<<60); /* auch ok, und kürzer. */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<bit); /* Ohne Warnung, und funktioniert manchmal, je nach Optimierung */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

return 0;
}
/* Ausgabe auf meinem PC ohne Optimierung:
* sizeof(int)=4
* 0
* 1
* 1
* 1
* Ausgabe auf meinem PC mit -O2
* 0
* 1
* 1
* 0
*/
</syntaxhighlight>

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<syntaxhighlight lang="c">
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="c">
Byte : 01101000
Byte-1: 01100111
Ergebnis:01100000

</syntaxhighlight>
Das funktioniert also mit jeder beliebigen Zahl.

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<syntaxhighlight lang="c">
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = ~par;
}
return par;
}
</syntaxhighlight>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bits invertieren ==

Im allgemeinen Sprachgebrauch oft Toggeln genannt (aus dem Englischen). Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies folgender Assemblercode. Hier wird ein Ausgangspin invertiert.

<syntaxhighlight lang="avrasm">
sbic PortB, 0 ; Überspringe den nächsten Befehl, wenn das Bit 0 im Port gelöscht ist
rjmp ClrBitNow ; Springe zu ClrBitNow
sbi PortB, 0 ; Setze Bit 0 in PortB
rjmp BitReady ; Springe BitReady
ClrBitNow:
cbi PortB, 0 ; Lösche Bit 0 in PortB
BitReady:
</syntaxhighlight>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln. Diese Methode ist natürlich auch auf normale Daten anwendbar, nicht nur auf IO-Ports.

<syntaxhighlight lang="avrasm">
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit #2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</syntaxhighlight>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<syntaxhighlight lang="avrasm">
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</syntaxhighlight>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z. B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<syntaxhighlight lang="asm">
sbi PIND, 2 ; Bit 2 von Port D togglen
</syntaxhighlight>

=== 8051er ===

<syntaxhighlight lang="asm">
cpl bitadresse
</syntaxhighlight>

== Bits prüfen ==

Will man prüfen ob ein oder mehrere Bits in einer Variable gesetzt oder gelöscht sind, muss man sie mit einer Bitmaske UND verknüpfen. Die Bitmaske muss an den Stellen der zu prüfenden Bits eine '1' haben, an allen anderen eine '0'.

* Ist das Ergebnis gleich Null, sind alle geprüften Bits gelöscht.
* Ist das Ergebnis ungleich Null, ist mindestens ein geprüftes Bit gesetzt.
* Ist das Ergebnis gleich der Bitmaske, sind alle geprüften Bits gesetzt.

=== AVR Assembler ===

Der AVR hat spezielle Befehle um direkt einzelne Bits in den CPU-Registern r0..r31 sowie den IO-Registern 0..0x1F zu prüfen.

<syntaxhighlight lang="asm">
; Befehle zur Prüfung von einzelnen Bits

sbrs r16,3 ; überspringe den nächsten Befehl, wenn in r16 Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbrc r16,5 ; überspringe den nächsten Befehl, wenn in r16 Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

sbis timsk,3 ; überspringe den nächsten Befehl, wenn in timsk Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbic timsk,5 ; überspringe den nächsten Befehl, wenn in timsk Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

; Befehle zur Prüfung von mehreren Bits

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
breq alle_bits_sind_geloescht

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
brne mind_ein_bit_ist_gesetzt

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
cpi r16,0b1010
breq alle_bits_sind_gesetzt
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
// prüfe ob Bit 4 in der Variable tmp gelöscht ist
// die Klammer ist wichtig
if (!(tmp & 0x10)) {
// hier die Anweisungen, wenn das Bit gelöscht ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0) {
// hier die Anweisungen, wenn beide Bits gelöscht sind
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gesetzt ist
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gelöscht sind
if (~tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gelöscht ist
}

// prüfe ob Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x10) {
// hier die Anweisungen, wenn das Bit gesetzt ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gesetzt sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0x11) {
// hier die Anweisungen, wenn beide Bits gesetzt sind
}
</syntaxhighlight>

== Hilfsfunktionen zur Bitmanipulation in C/C++ ==
Um "einfacher" elementare Bitmanipulationen durchzuführen bietet es sich an einige Hilfsfunktionen zu definieren. Dabei gibt es zwei verschiedene Möglichkeiten diese zu realiseren:
* Als C-Makro [[C_Makros]]
* Als Inline-Funktion
In beiden Fällen wird bei eingeschalteter Optimierung letztendlich vom Compiler ein sehr kompakter (und identischer!) Code erzeugt, jedoch ist dringend von der Verwendung von Makros abzuraten (siehe [[Makro]] )!
Im Fehlerfall zeigt der Compiler bei der Verwendung vom Makros keine eindeutigen Fehlermeldungen an, da es sich um simple Ersetzungen handelt - bei der Verwendung von Inline-Funktionen hingegen gibt es eine "brauchbare" Fehlermeldung!

=== Beispiele - Inline Variante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen über Pointer
// PORTA, PB2 setzen
BIT_SET(&PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(&PORTC, PB0);

// PORTA, PB2 direkt setzen
// HIGH
BIT_BOOL_SET(&PORTA, PB2, 1);

// LOW
BIT_BOOL_SET(&PORTA, PB2, 0);
</syntaxhighlight>

=== Beispiele - MakroVariante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen direkt über die Variablen/Portnamen
// PORTA, PB2 setzen
BIT_SET(PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(PORTC, PB0);
</syntaxhighlight>

Um die Hilfsfunktionen verwenden zu können einfach folgenden Code in eine neue Header-Datei (z.B. BitIO.h) kopieren:

=== Hilfsfunktionen als Inline-Methoden ===
Achtung: Wenn nur ein C Compiler verwendet wird, kennt dieser den Typ "bool" nicht, dieser muss dann vorher definiert werden!
<syntaxhighlight lang="c">
/**
* BitIO.h
* @author Andi Dittrich <http://andidittrich.de>
* @version 1.0
* @license MIT Style X11 License
*/

#include <inttypes.h>

#ifndef BITIO_H_
#define BITIO_H_

// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
*target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
*target &= ~(1<<bit);
};

// bit toogle
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit){
*target ^= (1<<bit);
};

// set bit by boolean
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable) __attribute__((always_inline));
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable){
if (enable){
BIT_SET(target, bit);
}else{
BIT_CLEAR(target, bit);
}
};

#endif /* BITIO_H_ */

</syntaxhighlight>

=== Hilfsfunktionen als C-Makro (nicht empfohlen) ===
<syntaxhighlight lang="c">
/* Bit setzen */
#define set_bit(var, bit) ((var) |= (1 << (bit)))

/* Bit löschen */
#define clear_bit(var, bit) ((var) &= (unsigned)~(1 << (bit)))

/* Bit togglen */
#define toggle_bit(var,bit) ((var) ^= (1 << (bit)))
</syntaxhighlight>

== Bitmanipulation beim MSP430 ==

Beim MSP430 und dessen Compilern sind die Bitnamen meist anders definiert. Und zwar nicht als Bitnummer, sondern als Bitmuster. Darum schreibt man dort die Bitzugriffe in C anders. Das kann auch bei anderen Mikrocontrollern bzw. C-Compilern so sein. Wichtig ist, dass man seine eignen Definitionen in der gleichen Weise wie der Compiler anlegt, um Verwirrung zu vermeiden, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]

<syntaxhighlight lang="c">
// Definition von Bitnamen in den Headerfiles des Compilers

#define PD4 4 // Definition im AVR GCC als Bitnummer
#define PD5 5

#define P14 (1<<4) // Definition im MSP430 GCC als Bitmuster
#define P15 (1<<5)

// Bitmanipulation im Programm

DDRD = (1<<PD5) | (1<<PD4); // AVR GCC
P1DIR = P15 | P14; // MSP430 GCC
</syntaxhighlight>

==Siehe auch==

* [http://www.mikrocontroller.net/topic/179566#1729219 Forumsbeitrag:] Bits aus einem Array extrahieren
* [http://www.mikrocontroller.net/topic/169509#1631439 Forumsbeitrag:] Bits für ein Schieberegister zusammenstellen, TLC5941
* [http://www.mikrocontroller.net/topic/353071?goto=3947567#3947567 Forumsbeitrag:] TLC5947 und ATmega16 Bitmanipulation
* [http://www.mikrocontroller.net/topic/15466?goto=107726#107720 Forumsbeitrag:] Bitreihenfolge ändern
* [http://www.mikrocontroller.net/topic/23866?goto=new#177674 Forumsbeitrag:] Wie drehe ich eine Bitreihenfolge um?
* [http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html AVR Build-in Functions], spezielle Funktion im avr-gcc zur schnellen Bitvertauschung, engl.

[[Category:8051]]
[[Category:AVR-Arithmetik]]

Bitmanipulation

2015-07-27T19:39:34Z

Mthomas: /* 8051er */

== Bitoperatoren ==

Bitoperatoren stammen ursprünglich aus dem Bereich des Maschinen-Codes und Assembler, existieren aber auch in den meisten Hochsprachen, wie C.

* >> = Rechts schieben
* << = Links schieben (Bsp: ''a<<b'' ist das gleiche wie ''a * 2^b''; bzw. bei 1<<3 wird die 1 um drei Stellen nach links geschoben)
* | = binäres ODER
* & = binäres UND
* ^ = binäres Exklusives ODER
* usw.

Bitoperatoren in dieser Schreibweise können in Assemblercode für
konstante Ausdrücke benutzt werden.

Beispiel:

<syntaxhighlight lang="asm">
ldi temp, (1<<3) | (1<<1) | (1<<2) | (1<<0)
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 8 | 2 | 4 | 1
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 15
</syntaxhighlight>

== Bitmaske ==

Im Folgenden ist häufiger von dem Begriff ''Bitmaske'' die Rede. Damit wird eine Folge von einzelnen Bit bezeichnet, die den Zustand Null ('0') oder Eins ('1') darstellen können.

Bitmasken werden im allgemeinen dazu verwendet, um unter Anwendung eines Operators (z. B. UND, ODER, XOR), eine Eingabe zu manipulieren. Das Ergebnis ist dann die Anwendung des Operators auf die Eingabe und der Bitmaske.

Wenn ein Operator eine Funktion mit zwei Argumenten ist, dann lässt sich dessen Anwendung wie folgt schreiben:

<syntaxhighlight lang="c">
Ergebnis = Operator( Eingabe, Bitmaske )
</syntaxhighlight>

Die Bitmaske ist häufig eine Konstante, da diese z. B. die Information über die Position einer Information in einem Register darstellt. Das kann z. B. ein Überlaufflag in einem Timer Statusregister sein.

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</syntaxhighlight>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setze Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0; bitweises ODER

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</syntaxhighlight>

Die letzte Zeile "entschlüsselt":

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''|=''' : Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB wieder zugewiesen.

<syntaxhighlight lang="c">
PORTB |= variable; // Kurzschreibweise
PORTB = PORTB | variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend gemäss, den C-Regeln, die 1 als Integer Typ ansieht. Beim AVR-GCC bedeutet das 16-Bit/signed und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<syntaxhighlight lang="c">
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32; /* uint32_t definiert per typedef z. B. in stdint.h */
uint64_t reg_64; /* uint64_t definiert per typedef z. B. in stdint.h */

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1U << MEINBIT15); /* */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</syntaxhighlight>

Bei Compilern für 32bit Controller (z. B. ARM7TDMI) sind Integers per default 32-bit und Konstanten sind somit implizit ebenfalls 32-bit. Man sollte aber dennoch die oben gezeigte Vorgehenweise verwenden, um Probleme zu vermeiden die entstehen könnten, wenn Code unter verschiedenen Plattformen/Compilern verwendet werden soll.

== Bits löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
cbr r16, 0b00001111 ; löscht Bits 0-3 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden weil dieser Bereich nicht
; bitadressierbar ist
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, 1<<TOIE1
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, 1<<RXCIE0
sts UCSR0B, r16
</syntaxhighlight>

Auch hier gilt: Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 2 und 0" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-NOT-Verknüpfung (nicht zu verwechseln mit NAND), während der Befehl '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation << erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0; bitweises UND
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</syntaxhighlight>

Die letzte Zeile entschlüsselt:

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''~''' : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
# '''&=''' : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.

<syntaxhighlight lang="c">
PORTB &= variable; // Kurzschreibweise
PORTB = PORTB & variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111111, dann ist der Inhalt nach der Operation 0b01111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits 0 und 2 sind somit gelöscht.

Die C-Ausdrücke mittels Definitionen von Bitnummern und Schieboperator (<<) sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind deutlicher und nachvollziehbarer als "handoptimierte" Konstanten. Bei eingeschalteter Optimierung löst der Compiler die Ausdücke mit konstanten Werten bereits zur Compilierungszeit auf und es entsteht kein zusätzlicher Maschinencode. Bei AVR sind die Definitionen meist Teil der Entwicklungsumgebungen (bei avr-libc z. B. implizit durch #include <avr/io.h>). Sie entsprechen den Angaben und Beispielen in den Datenblättern und sind damit de-facto ein Standard beim Zugriff auf Bits in Hardware-Registern.

'''Wichtiger Hinweis''': Die ODER-Verknüpfung und die anschliessende Invertierung kann man nicht vertauschen! (Theorem von DeMorgan) Folgendes Beispiel soll die Richtigkeit der Aussage zeigen:

<syntaxhighlight lang="c">
~(0b0001 | 0b0010) == 0b1100
~0b0001 | ~0b0010 == 0b1111
</syntaxhighlight>

'''Noch ein wichtiger Hinweis''': Der operator ~ mit einem Operanden vom Typ int negiert nur so viele bits, wie der Typ int hat.
Will man ein bit in einer breiteren Variablen löschen, dann sollte die nach links zu shiftende 1 den Typ dieser Variablen haben.

Ein Programm, welches das verdeutlicht:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdint.h>

int main(int argc, const char* argv[])
{
int bit = 60;
uint64_t ui64;
printf("sizeof(int)=%d\n", (int)sizeof(int));

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<60); /* Keine Wirkung bei sizeof(int) < 8 */
/* gcc warnt sogar:
* gcc -Wall bit_clear.c -o bit_clear
* bit_clear.c: In function ‘main’:
* bit_clear.c:11:5: warning: left shift count >= width of type [enabled by default]
*/
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~((uint64_t)1<<60); /* ok */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1LL<<60); /* auch ok, und kürzer. */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<bit); /* Ohne Warnung, und funktioniert manchmal, je nach Optimierung */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

return 0;
}
/* Ausgabe auf meinem PC ohne Optimierung:
* sizeof(int)=4
* 0
* 1
* 1
* 1
* Ausgabe auf meinem PC mit -O2
* 0
* 1
* 1
* 0
*/
</syntaxhighlight>

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<syntaxhighlight lang="c">
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="c">
Byte : 01101000
Byte-1: 01100111
Ergebnis:01100000

</syntaxhighlight>
Das funktioniert also mit jeder beliebigen Zahl.

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<syntaxhighlight lang="c">
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = ~par;
}
return par;
}
</syntaxhighlight>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bits invertieren ==

Im allgemeinen Sprachgebrauch oft Toggeln genannt (aus dem Englischen). Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies folgender Assemblercode. Hier wird ein Ausgangspin invertiert.

<syntaxhighlight lang="avrasm">
sbic PortB, 0 ; Überspringe den nächsten Befehl, wenn das Bit 0 im Port gelöscht ist
rjmp ClrBitNow ; Springe zu ClrBitNow
sbi PortB, 0 ; Setze Bit 0 in PortB
rjmp BitReady ; Springe BitReady
ClrBitNow:
cbi PortB, 0 ; Lösche Bit 0 in PortB
BitReady:
</syntaxhighlight>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln. Diese Methode ist natürlich auch auf normale Daten anwendbar, nicht nur auf IO-Ports.

<syntaxhighlight lang="avrasm">
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit #2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</syntaxhighlight>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<syntaxhighlight lang="avrasm">
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</syntaxhighlight>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z. B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<syntaxhighlight lang="avrasm">
sbi PIND, 2 ; Bit 2 von Port D togglen
</syntaxhighlight>

=== 8051er ===

<syntaxhighlight lang="asm">
cpl bitadresse
</syntaxhighlight>

== Bits prüfen ==

Will man prüfen ob ein oder mehrere Bits in einer Variable gesetzt oder gelöscht sind, muss man sie mit einer Bitmaske UND verknüpfen. Die Bitmaske muss an den Stellen der zu prüfenden Bits eine '1' haben, an allen anderen eine '0'.

* Ist das Ergebnis gleich Null, sind alle geprüften Bits gelöscht.
* Ist das Ergebnis ungleich Null, ist mindestens ein geprüftes Bit gesetzt.
* Ist das Ergebnis gleich der Bitmaske, sind alle geprüften Bits gesetzt.

=== AVR Assembler ===

Der AVR hat spezielle Befehle um direkt einzelne Bits in den CPU-Registern r0..r31 sowie den IO-Registern 0..0x1F zu prüfen.

<syntaxhighlight lang="asm">
; Befehle zur Prüfung von einzelnen Bits

sbrs r16,3 ; überspringe den nächsten Befehl, wenn in r16 Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbrc r16,5 ; überspringe den nächsten Befehl, wenn in r16 Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

sbis timsk,3 ; überspringe den nächsten Befehl, wenn in timsk Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbic timsk,5 ; überspringe den nächsten Befehl, wenn in timsk Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

; Befehle zur Prüfung von mehreren Bits

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
breq alle_bits_sind_geloescht

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
brne mind_ein_bit_ist_gesetzt

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
cpi r16,0b1010
breq alle_bits_sind_gesetzt
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
// prüfe ob Bit 4 in der Variable tmp gelöscht ist
// die Klammer ist wichtig
if (!(tmp & 0x10)) {
// hier die Anweisungen, wenn das Bit gelöscht ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0) {
// hier die Anweisungen, wenn beide Bits gelöscht sind
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gesetzt ist
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gelöscht sind
if (~tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gelöscht ist
}

// prüfe ob Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x10) {
// hier die Anweisungen, wenn das Bit gesetzt ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gesetzt sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0x11) {
// hier die Anweisungen, wenn beide Bits gesetzt sind
}
</syntaxhighlight>

== Hilfsfunktionen zur Bitmanipulation in C/C++ ==
Um "einfacher" elementare Bitmanipulationen durchzuführen bietet es sich an einige Hilfsfunktionen zu definieren. Dabei gibt es zwei verschiedene Möglichkeiten diese zu realiseren:
* Als C-Makro [[C_Makros]]
* Als Inline-Funktion
In beiden Fällen wird bei eingeschalteter Optimierung letztendlich vom Compiler ein sehr kompakter (und identischer!) Code erzeugt, jedoch ist dringend von der Verwendung von Makros abzuraten (siehe [[Makro]] )!
Im Fehlerfall zeigt der Compiler bei der Verwendung vom Makros keine eindeutigen Fehlermeldungen an, da es sich um simple Ersetzungen handelt - bei der Verwendung von Inline-Funktionen hingegen gibt es eine "brauchbare" Fehlermeldung!

=== Beispiele - Inline Variante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen über Pointer
// PORTA, PB2 setzen
BIT_SET(&PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(&PORTC, PB0);

// PORTA, PB2 direkt setzen
// HIGH
BIT_BOOL_SET(&PORTA, PB2, 1);

// LOW
BIT_BOOL_SET(&PORTA, PB2, 0);
</syntaxhighlight>

=== Beispiele - MakroVariante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen direkt über die Variablen/Portnamen
// PORTA, PB2 setzen
BIT_SET(PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(PORTC, PB0);
</syntaxhighlight>

Um die Hilfsfunktionen verwenden zu können einfach folgenden Code in eine neue Header-Datei (z.B. BitIO.h) kopieren:

=== Hilfsfunktionen als Inline-Methoden ===
Achtung: Wenn nur ein C Compiler verwendet wird, kennt dieser den Typ "bool" nicht, dieser muss dann vorher definiert werden!
<syntaxhighlight lang="c">
/**
* BitIO.h
* @author Andi Dittrich <http://andidittrich.de>
* @version 1.0
* @license MIT Style X11 License
*/

#include <inttypes.h>

#ifndef BITIO_H_
#define BITIO_H_

// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
*target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
*target &= ~(1<<bit);
};

// bit toogle
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit){
*target ^= (1<<bit);
};

// set bit by boolean
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable) __attribute__((always_inline));
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable){
if (enable){
BIT_SET(target, bit);
}else{
BIT_CLEAR(target, bit);
}
};

#endif /* BITIO_H_ */

</syntaxhighlight>

=== Hilfsfunktionen als C-Makro (nicht empfohlen) ===
<syntaxhighlight lang="c">
/* Bit setzen */
#define set_bit(var, bit) ((var) |= (1 << (bit)))

/* Bit löschen */
#define clear_bit(var, bit) ((var) &= (unsigned)~(1 << (bit)))

/* Bit togglen */
#define toggle_bit(var,bit) ((var) ^= (1 << (bit)))
</syntaxhighlight>

== Bitmanipulation beim MSP430 ==

Beim MSP430 und dessen Compilern sind die Bitnamen meist anders definiert. Und zwar nicht als Bitnummer, sondern als Bitmuster. Darum schreibt man dort die Bitzugriffe in C anders. Das kann auch bei anderen Mikrocontrollern bzw. C-Compilern so sein. Wichtig ist, dass man seine eignen Definitionen in der gleichen Weise wie der Compiler anlegt, um Verwirrung zu vermeiden, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]

<syntaxhighlight lang="c">
// Definition von Bitnamen in den Headerfiles des Compilers

#define PD4 4 // Definition im AVR GCC als Bitnummer
#define PD5 5

#define P14 (1<<4) // Definition im MSP430 GCC als Bitmuster
#define P15 (1<<5)

// Bitmanipulation im Programm

DDRD = (1<<PD5) | (1<<PD4); // AVR GCC
P1DIR = P15 | P14; // MSP430 GCC
</syntaxhighlight>

==Siehe auch==

* [http://www.mikrocontroller.net/topic/179566#1729219 Forumsbeitrag:] Bits aus einem Array extrahieren
* [http://www.mikrocontroller.net/topic/169509#1631439 Forumsbeitrag:] Bits für ein Schieberegister zusammenstellen, TLC5941
* [http://www.mikrocontroller.net/topic/353071?goto=3947567#3947567 Forumsbeitrag:] TLC5947 und ATmega16 Bitmanipulation
* [http://www.mikrocontroller.net/topic/15466?goto=107726#107720 Forumsbeitrag:] Bitreihenfolge ändern
* [http://www.mikrocontroller.net/topic/23866?goto=new#177674 Forumsbeitrag:] Wie drehe ich eine Bitreihenfolge um?
* [http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html AVR Build-in Functions], spezielle Funktion im avr-gcc zur schnellen Bitvertauschung, engl.

[[Category:8051]]
[[Category:AVR-Arithmetik]]

Bitmanipulation

2015-07-27T19:39:08Z

Mthomas: /* AVR Assembler */

== Bitoperatoren ==

Bitoperatoren stammen ursprünglich aus dem Bereich des Maschinen-Codes und Assembler, existieren aber auch in den meisten Hochsprachen, wie C.

* >> = Rechts schieben
* << = Links schieben (Bsp: ''a<<b'' ist das gleiche wie ''a * 2^b''; bzw. bei 1<<3 wird die 1 um drei Stellen nach links geschoben)
* | = binäres ODER
* & = binäres UND
* ^ = binäres Exklusives ODER
* usw.

Bitoperatoren in dieser Schreibweise können in Assemblercode für
konstante Ausdrücke benutzt werden.

Beispiel:

<syntaxhighlight lang="asm">
ldi temp, (1<<3) | (1<<1) | (1<<2) | (1<<0)
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 8 | 2 | 4 | 1
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 15
</syntaxhighlight>

== Bitmaske ==

Im Folgenden ist häufiger von dem Begriff ''Bitmaske'' die Rede. Damit wird eine Folge von einzelnen Bit bezeichnet, die den Zustand Null ('0') oder Eins ('1') darstellen können.

Bitmasken werden im allgemeinen dazu verwendet, um unter Anwendung eines Operators (z. B. UND, ODER, XOR), eine Eingabe zu manipulieren. Das Ergebnis ist dann die Anwendung des Operators auf die Eingabe und der Bitmaske.

Wenn ein Operator eine Funktion mit zwei Argumenten ist, dann lässt sich dessen Anwendung wie folgt schreiben:

<syntaxhighlight lang="c">
Ergebnis = Operator( Eingabe, Bitmaske )
</syntaxhighlight>

Die Bitmaske ist häufig eine Konstante, da diese z. B. die Information über die Position einer Information in einem Register darstellt. Das kann z. B. ein Überlaufflag in einem Timer Statusregister sein.

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</syntaxhighlight>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setze Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0; bitweises ODER

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</syntaxhighlight>

Die letzte Zeile "entschlüsselt":

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''|=''' : Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB wieder zugewiesen.

<syntaxhighlight lang="c">
PORTB |= variable; // Kurzschreibweise
PORTB = PORTB | variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend gemäss, den C-Regeln, die 1 als Integer Typ ansieht. Beim AVR-GCC bedeutet das 16-Bit/signed und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<syntaxhighlight lang="c">
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32; /* uint32_t definiert per typedef z. B. in stdint.h */
uint64_t reg_64; /* uint64_t definiert per typedef z. B. in stdint.h */

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1U << MEINBIT15); /* */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</syntaxhighlight>

Bei Compilern für 32bit Controller (z. B. ARM7TDMI) sind Integers per default 32-bit und Konstanten sind somit implizit ebenfalls 32-bit. Man sollte aber dennoch die oben gezeigte Vorgehenweise verwenden, um Probleme zu vermeiden die entstehen könnten, wenn Code unter verschiedenen Plattformen/Compilern verwendet werden soll.

== Bits löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
cbr r16, 0b00001111 ; löscht Bits 0-3 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden weil dieser Bereich nicht
; bitadressierbar ist
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, 1<<TOIE1
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, 1<<RXCIE0
sts UCSR0B, r16
</syntaxhighlight>

Auch hier gilt: Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 2 und 0" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-NOT-Verknüpfung (nicht zu verwechseln mit NAND), während der Befehl '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation << erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0; bitweises UND
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</syntaxhighlight>

Die letzte Zeile entschlüsselt:

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''~''' : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
# '''&=''' : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.

<syntaxhighlight lang="c">
PORTB &= variable; // Kurzschreibweise
PORTB = PORTB & variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111111, dann ist der Inhalt nach der Operation 0b01111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits 0 und 2 sind somit gelöscht.

Die C-Ausdrücke mittels Definitionen von Bitnummern und Schieboperator (<<) sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind deutlicher und nachvollziehbarer als "handoptimierte" Konstanten. Bei eingeschalteter Optimierung löst der Compiler die Ausdücke mit konstanten Werten bereits zur Compilierungszeit auf und es entsteht kein zusätzlicher Maschinencode. Bei AVR sind die Definitionen meist Teil der Entwicklungsumgebungen (bei avr-libc z. B. implizit durch #include <avr/io.h>). Sie entsprechen den Angaben und Beispielen in den Datenblättern und sind damit de-facto ein Standard beim Zugriff auf Bits in Hardware-Registern.

'''Wichtiger Hinweis''': Die ODER-Verknüpfung und die anschliessende Invertierung kann man nicht vertauschen! (Theorem von DeMorgan) Folgendes Beispiel soll die Richtigkeit der Aussage zeigen:

<syntaxhighlight lang="c">
~(0b0001 | 0b0010) == 0b1100
~0b0001 | ~0b0010 == 0b1111
</syntaxhighlight>

'''Noch ein wichtiger Hinweis''': Der operator ~ mit einem Operanden vom Typ int negiert nur so viele bits, wie der Typ int hat.
Will man ein bit in einer breiteren Variablen löschen, dann sollte die nach links zu shiftende 1 den Typ dieser Variablen haben.

Ein Programm, welches das verdeutlicht:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdint.h>

int main(int argc, const char* argv[])
{
int bit = 60;
uint64_t ui64;
printf("sizeof(int)=%d\n", (int)sizeof(int));

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<60); /* Keine Wirkung bei sizeof(int) < 8 */
/* gcc warnt sogar:
* gcc -Wall bit_clear.c -o bit_clear
* bit_clear.c: In function ‘main’:
* bit_clear.c:11:5: warning: left shift count >= width of type [enabled by default]
*/
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~((uint64_t)1<<60); /* ok */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1LL<<60); /* auch ok, und kürzer. */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<bit); /* Ohne Warnung, und funktioniert manchmal, je nach Optimierung */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

return 0;
}
/* Ausgabe auf meinem PC ohne Optimierung:
* sizeof(int)=4
* 0
* 1
* 1
* 1
* Ausgabe auf meinem PC mit -O2
* 0
* 1
* 1
* 0
*/
</syntaxhighlight>

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<syntaxhighlight lang="c">
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="c">
Byte : 01101000
Byte-1: 01100111
Ergebnis:01100000

</syntaxhighlight>
Das funktioniert also mit jeder beliebigen Zahl.

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<syntaxhighlight lang="c">
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = ~par;
}
return par;
}
</syntaxhighlight>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bits invertieren ==

Im allgemeinen Sprachgebrauch oft Toggeln genannt (aus dem Englischen). Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies folgender Assemblercode. Hier wird ein Ausgangspin invertiert.

<syntaxhighlight lang="avrasm">
sbic PortB, 0 ; Überspringe den nächsten Befehl, wenn das Bit 0 im Port gelöscht ist
rjmp ClrBitNow ; Springe zu ClrBitNow
sbi PortB, 0 ; Setze Bit 0 in PortB
rjmp BitReady ; Springe BitReady
ClrBitNow:
cbi PortB, 0 ; Lösche Bit 0 in PortB
BitReady:
</syntaxhighlight>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln. Diese Methode ist natürlich auch auf normale Daten anwendbar, nicht nur auf IO-Ports.

<syntaxhighlight lang="avrasm">
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit #2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</syntaxhighlight>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<syntaxhighlight lang="avrasm">
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</syntaxhighlight>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z. B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<syntaxhighlight lang="avrasm">
sbi PIND, 2 ; Bit 2 von Port D togglen
</syntaxhighlight>

=== 8051er ===

<syntaxhighlight lang="avrasm">
cpl bitadresse
</syntaxhighlight>

== Bits prüfen ==

Will man prüfen ob ein oder mehrere Bits in einer Variable gesetzt oder gelöscht sind, muss man sie mit einer Bitmaske UND verknüpfen. Die Bitmaske muss an den Stellen der zu prüfenden Bits eine '1' haben, an allen anderen eine '0'.

* Ist das Ergebnis gleich Null, sind alle geprüften Bits gelöscht.
* Ist das Ergebnis ungleich Null, ist mindestens ein geprüftes Bit gesetzt.
* Ist das Ergebnis gleich der Bitmaske, sind alle geprüften Bits gesetzt.

=== AVR Assembler ===

Der AVR hat spezielle Befehle um direkt einzelne Bits in den CPU-Registern r0..r31 sowie den IO-Registern 0..0x1F zu prüfen.

<syntaxhighlight lang="asm">
; Befehle zur Prüfung von einzelnen Bits

sbrs r16,3 ; überspringe den nächsten Befehl, wenn in r16 Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbrc r16,5 ; überspringe den nächsten Befehl, wenn in r16 Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

sbis timsk,3 ; überspringe den nächsten Befehl, wenn in timsk Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbic timsk,5 ; überspringe den nächsten Befehl, wenn in timsk Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

; Befehle zur Prüfung von mehreren Bits

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
breq alle_bits_sind_geloescht

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
brne mind_ein_bit_ist_gesetzt

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
cpi r16,0b1010
breq alle_bits_sind_gesetzt
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
// prüfe ob Bit 4 in der Variable tmp gelöscht ist
// die Klammer ist wichtig
if (!(tmp & 0x10)) {
// hier die Anweisungen, wenn das Bit gelöscht ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0) {
// hier die Anweisungen, wenn beide Bits gelöscht sind
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gesetzt ist
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gelöscht sind
if (~tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gelöscht ist
}

// prüfe ob Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x10) {
// hier die Anweisungen, wenn das Bit gesetzt ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gesetzt sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0x11) {
// hier die Anweisungen, wenn beide Bits gesetzt sind
}
</syntaxhighlight>

== Hilfsfunktionen zur Bitmanipulation in C/C++ ==
Um "einfacher" elementare Bitmanipulationen durchzuführen bietet es sich an einige Hilfsfunktionen zu definieren. Dabei gibt es zwei verschiedene Möglichkeiten diese zu realiseren:
* Als C-Makro [[C_Makros]]
* Als Inline-Funktion
In beiden Fällen wird bei eingeschalteter Optimierung letztendlich vom Compiler ein sehr kompakter (und identischer!) Code erzeugt, jedoch ist dringend von der Verwendung von Makros abzuraten (siehe [[Makro]] )!
Im Fehlerfall zeigt der Compiler bei der Verwendung vom Makros keine eindeutigen Fehlermeldungen an, da es sich um simple Ersetzungen handelt - bei der Verwendung von Inline-Funktionen hingegen gibt es eine "brauchbare" Fehlermeldung!

=== Beispiele - Inline Variante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen über Pointer
// PORTA, PB2 setzen
BIT_SET(&PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(&PORTC, PB0);

// PORTA, PB2 direkt setzen
// HIGH
BIT_BOOL_SET(&PORTA, PB2, 1);

// LOW
BIT_BOOL_SET(&PORTA, PB2, 0);
</syntaxhighlight>

=== Beispiele - MakroVariante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen direkt über die Variablen/Portnamen
// PORTA, PB2 setzen
BIT_SET(PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(PORTC, PB0);
</syntaxhighlight>

Um die Hilfsfunktionen verwenden zu können einfach folgenden Code in eine neue Header-Datei (z.B. BitIO.h) kopieren:

=== Hilfsfunktionen als Inline-Methoden ===
Achtung: Wenn nur ein C Compiler verwendet wird, kennt dieser den Typ "bool" nicht, dieser muss dann vorher definiert werden!
<syntaxhighlight lang="c">
/**
* BitIO.h
* @author Andi Dittrich <http://andidittrich.de>
* @version 1.0
* @license MIT Style X11 License
*/

#include <inttypes.h>

#ifndef BITIO_H_
#define BITIO_H_

// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
*target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
*target &= ~(1<<bit);
};

// bit toogle
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit){
*target ^= (1<<bit);
};

// set bit by boolean
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable) __attribute__((always_inline));
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable){
if (enable){
BIT_SET(target, bit);
}else{
BIT_CLEAR(target, bit);
}
};

#endif /* BITIO_H_ */

</syntaxhighlight>

=== Hilfsfunktionen als C-Makro (nicht empfohlen) ===
<syntaxhighlight lang="c">
/* Bit setzen */
#define set_bit(var, bit) ((var) |= (1 << (bit)))

/* Bit löschen */
#define clear_bit(var, bit) ((var) &= (unsigned)~(1 << (bit)))

/* Bit togglen */
#define toggle_bit(var,bit) ((var) ^= (1 << (bit)))
</syntaxhighlight>

== Bitmanipulation beim MSP430 ==

Beim MSP430 und dessen Compilern sind die Bitnamen meist anders definiert. Und zwar nicht als Bitnummer, sondern als Bitmuster. Darum schreibt man dort die Bitzugriffe in C anders. Das kann auch bei anderen Mikrocontrollern bzw. C-Compilern so sein. Wichtig ist, dass man seine eignen Definitionen in der gleichen Weise wie der Compiler anlegt, um Verwirrung zu vermeiden, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]

<syntaxhighlight lang="c">
// Definition von Bitnamen in den Headerfiles des Compilers

#define PD4 4 // Definition im AVR GCC als Bitnummer
#define PD5 5

#define P14 (1<<4) // Definition im MSP430 GCC als Bitmuster
#define P15 (1<<5)

// Bitmanipulation im Programm

DDRD = (1<<PD5) | (1<<PD4); // AVR GCC
P1DIR = P15 | P14; // MSP430 GCC
</syntaxhighlight>

==Siehe auch==

* [http://www.mikrocontroller.net/topic/179566#1729219 Forumsbeitrag:] Bits aus einem Array extrahieren
* [http://www.mikrocontroller.net/topic/169509#1631439 Forumsbeitrag:] Bits für ein Schieberegister zusammenstellen, TLC5941
* [http://www.mikrocontroller.net/topic/353071?goto=3947567#3947567 Forumsbeitrag:] TLC5947 und ATmega16 Bitmanipulation
* [http://www.mikrocontroller.net/topic/15466?goto=107726#107720 Forumsbeitrag:] Bitreihenfolge ändern
* [http://www.mikrocontroller.net/topic/23866?goto=new#177674 Forumsbeitrag:] Wie drehe ich eine Bitreihenfolge um?
* [http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html AVR Build-in Functions], spezielle Funktion im avr-gcc zur schnellen Bitvertauschung, engl.

[[Category:8051]]
[[Category:AVR-Arithmetik]]

Bitmanipulation

2015-07-27T19:38:13Z

Mthomas: /* Bitoperatoren */

== Bitoperatoren ==

Bitoperatoren stammen ursprünglich aus dem Bereich des Maschinen-Codes und Assembler, existieren aber auch in den meisten Hochsprachen, wie C.

* >> = Rechts schieben
* << = Links schieben (Bsp: ''a<<b'' ist das gleiche wie ''a * 2^b''; bzw. bei 1<<3 wird die 1 um drei Stellen nach links geschoben)
* | = binäres ODER
* & = binäres UND
* ^ = binäres Exklusives ODER
* usw.

Bitoperatoren in dieser Schreibweise können in Assemblercode für
konstante Ausdrücke benutzt werden.

Beispiel:

<syntaxhighlight lang="asm">
ldi temp, (1<<3) | (1<<1) | (1<<2) | (1<<0)
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 8 | 2 | 4 | 1
</syntaxhighlight>

wird zu:

<syntaxhighlight lang="asm">
ldi temp, 15
</syntaxhighlight>

== Bitmaske ==

Im Folgenden ist häufiger von dem Begriff ''Bitmaske'' die Rede. Damit wird eine Folge von einzelnen Bit bezeichnet, die den Zustand Null ('0') oder Eins ('1') darstellen können.

Bitmasken werden im allgemeinen dazu verwendet, um unter Anwendung eines Operators (z. B. UND, ODER, XOR), eine Eingabe zu manipulieren. Das Ergebnis ist dann die Anwendung des Operators auf die Eingabe und der Bitmaske.

Wenn ein Operator eine Funktion mit zwei Argumenten ist, dann lässt sich dessen Anwendung wie folgt schreiben:

<syntaxhighlight lang="c">
Ergebnis = Operator( Eingabe, Bitmaske )
</syntaxhighlight>

Die Bitmaske ist häufig eine Konstante, da diese z. B. die Information über die Position einer Information in einem Register darstellt. Das kann z. B. ein Überlaufflag in einem Timer Statusregister sein.

== Bits setzen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Eins gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#ODER | ODER]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden auf '1' gesetzt. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
sbr r16, 0b11110000 ; setzt Bits 4-7 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

ori r16, 0b11110000 ; setzt Bits 4-7 in r16, ori ist identisch mit sbr
; funktioniert nur für die Arbeitsregister r16-r31

sbi PORTB, 5 ; setzt Bit 5 in PortB
sbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..0x1F

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden
in r16, TIMSK ; setzt Bit TOIE1 in TIMSK
sbr r16, (1<<TOIE1)
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; setzt Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
sbr r16, (1<<RXCIE0)
sts UCSR0B, r16
</syntaxhighlight>

Man beachte den Unterschied! Eine "5" würde von sbr als "setze Bit 2 und 0" gedeutet (=0b00000101), während sbi sie als "setze Bit 5" versteht. Der Befehl '''sbr''' erwartet ein Bit'''muster''' für eine ODER-Verknüpfung, während der Befehlt '''sbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] (C) ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB |= 0xF0; // Kurzschreibweise, entspricht PORTB = PORTB | 0xF0; bitweises ODER

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB |= ((1 << MEINBIT0) | (1 << MEINBIT2)); // setzt Bit 0 und 2 in PORTB auf "1"
</syntaxhighlight>

Die letzte Zeile "entschlüsselt":

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft, also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''|=''' : Diese Maske wird mit dem aktuellen Inhalt von PORTB bitweise ODER-verknüpft und das Ergebnis PORTB wieder zugewiesen.

<syntaxhighlight lang="c">
PORTB |= variable; // Kurzschreibweise
PORTB = PORTB | variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111010, dann ist der Inhalt nach der Operation 0b01111010 ''or'' 0b00000101 = 0b01111111, die gewünschten Bits sind somit gesetzt!

Anmerkung: Will man das gezeigte Beispiel der Bitmanipulation auf größere Datentypen anwenden, ist zu beachten, dass der Compiler in der Operation (1 << MEINBIT1) stillschweigend gemäss, den C-Regeln, die 1 als Integer Typ ansieht. Beim AVR-GCC bedeutet das 16-Bit/signed und die folgende Operation bringt ggf. nicht das gewünschte Ergebnis. (Stichwort: "Integer Promotion").

Angenommen Bit 15 soll in einer 32-Bit weiten Variable gesetzt werden.

<syntaxhighlight lang="c">
#define MEINBIT15 15
#define MEINBIT42 42

uint32_t reg_32; /* uint32_t definiert per typedef z. B. in stdint.h */
uint64_t reg_64; /* uint64_t definiert per typedef z. B. in stdint.h */

reg_32 |= (1 << MEINBIT15); /* FEHLER: Setzt die Bits 31 - 15, da ((int)1 << 15) == 0xFFFF8000 */

reg_32 |= ((uint32_t)1 << MEINBIT15); /* Hier wird nur Bit 15 gesetzt. */
reg_32 |= (1U << MEINBIT15); /* */
reg_32 |= (1L << MEINBIT15); /* andere Schreibweise. */
reg_64 |= (1LL << MEINBIT42); /* Hier wird nur Bit 42 gesetzt,
andere Schreibweise für 64 Bit (long long). */
</syntaxhighlight>

Bei Compilern für 32bit Controller (z. B. ARM7TDMI) sind Integers per default 32-bit und Konstanten sind somit implizit ebenfalls 32-bit. Man sollte aber dennoch die oben gezeigte Vorgehenweise verwenden, um Probleme zu vermeiden die entstehen könnten, wenn Code unter verschiedenen Plattformen/Compilern verwendet werden soll.

== Bits löschen ==

Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] auf Null gesetzt werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#UND | UND]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '0' sind, werden auf '0' gesetzt. Alle Bits, die in der Maske auf '1' gesetzt sind, bleiben unverändert.

=== AVR-Assembler ===

<syntaxhighlight lang="avrasm">
cbr r16, 0b00001111 ; löscht Bits 0-3 in r16, ist ein Pseudobefehl
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, 0b11110000 ; löscht Bits 0-3 in r16, andi ist identisch mit cbr
; funktioniert nur für die Arbeitsregister r16-r31

andi r16, ~0b00001111 ; andere Schreibweise, hier wird die Bitmaske durch ~ invertiert
; dadurch kann man einfach alle zu löschenden Bit als '1' angeben
; so wie bei den Bitmasken für das setzen von Bits (positive Logik)

cbi PORTB, 5 ; löscht Bit 5 in PortB
cbi PORTB, PB5 ; identisch, besser lesbar
; funktioniert nur für die IO-Register 0..31

; für I/O Register mit I/O Adresse 0x20..0x3F muss
; in/out verwendet werden weil dieser Bereich nicht
; bitadressierbar ist
in r16, TIMSK ; löscht Bit TOIE1 in TIMSK
cbr r16, 1<<TOIE1
out TIMSK, r16

; für I/O Register oberhalb der I/O Adresse 0x3F muss
; lds/sts verwednet werden
; löscht Bit RXCIE0 in UCSR0B
lds r16, UCSR0B
cbr r16, 1<<RXCIE0
sts UCSR0B, r16
</syntaxhighlight>

Auch hier gilt: Man beachte den Unterschied! Eine "5" würde von cbr als "lösche Bit 2 und 0" gedeutet, während cbi sie als "lösche Bit 5" versteht. Der Befehl '''cbr''' erwartet ein Bit'''muster''' für eine UND-NOT-Verknüpfung (nicht zu verwechseln mit NAND), während der Befehl '''cbi''' die Bit'''nummer''' benötigt. Darauf sind auch die Includefiles von Atmel im AVR-Studio (Assembler) als auch [[WinAVR]] ausgelegt. Die Namen der Bits sind als Bit'''nummer''' definiert. Das ist wichtig, wenn man Register von grossen AVRs manipuliert, z. B. ATmega48. Hier muss aus der Bitnummer über eine Schiebeoperation << erst das Bit'''muster''' gemacht werden.

=== Standard C ===

<syntaxhighlight lang="c">
PORTB &= 0xF0; // entspricht PORTB = PORTB & 0xF0; bitweises UND
// Bits 0-3 (das "niederwertige" Nibble) werden geloescht

/* übersichtlicher mittels Bit-Definitionen */
#define MEINBIT0 0
#define MEINBIT1 1
#define MEINBIT2 2

PORTB &= ~((1 << MEINBIT0) | (1 << MEINBIT2)); // löscht Bit 0 und 2 in PORTB
</syntaxhighlight>

Die letzte Zeile entschlüsselt:

# '''(1 << n)''' : Zuerst wird durch die '<<'-Ausdrücke eine "1" n-mal nach links geschoben. Dies ergibt somit (in Binärschreibweise) 0b00000001 für (1 << MEINBIT0) und 0b00000100 für (1 << MEINBIT2).
# '''|''' : Das Ergebnis wird bitweise ODER-verknüpft also 0b00000001 ''or'' 0b00000100 wird zu 0b00000101.
# '''~''' : Der Wert in der Klammer wird bitweise invertiert, aus 0b00000101 wird 0b11111010.
# '''&=''' : PORTB wird mit der berechneten Maske UND-verknüpft und das Ergebnis wieder PORTB zugewiesen.

<syntaxhighlight lang="c">
PORTB &= variable; // Kurzschreibweise
PORTB = PORTB & variable; // lange Schreibweise
</syntaxhighlight>

: Ist PORTB vorher z. B. 0b01111111, dann ist der Inhalt nach der Operation 0b01111111 ''and'' 0b11111010 = 0b01111010, die gewünschten Bits 0 und 2 sind somit gelöscht.

Die C-Ausdrücke mittels Definitionen von Bitnummern und Schieboperator (<<) sehen auf den ersten Blick etwas "erschreckend" aus und sind mehr "Tipparbeit", funktionieren aber universell und sind deutlicher und nachvollziehbarer als "handoptimierte" Konstanten. Bei eingeschalteter Optimierung löst der Compiler die Ausdücke mit konstanten Werten bereits zur Compilierungszeit auf und es entsteht kein zusätzlicher Maschinencode. Bei AVR sind die Definitionen meist Teil der Entwicklungsumgebungen (bei avr-libc z. B. implizit durch #include <avr/io.h>). Sie entsprechen den Angaben und Beispielen in den Datenblättern und sind damit de-facto ein Standard beim Zugriff auf Bits in Hardware-Registern.

'''Wichtiger Hinweis''': Die ODER-Verknüpfung und die anschliessende Invertierung kann man nicht vertauschen! (Theorem von DeMorgan) Folgendes Beispiel soll die Richtigkeit der Aussage zeigen:

<syntaxhighlight lang="c">
~(0b0001 | 0b0010) == 0b1100
~0b0001 | ~0b0010 == 0b1111
</syntaxhighlight>

'''Noch ein wichtiger Hinweis''': Der operator ~ mit einem Operanden vom Typ int negiert nur so viele bits, wie der Typ int hat.
Will man ein bit in einer breiteren Variablen löschen, dann sollte die nach links zu shiftende 1 den Typ dieser Variablen haben.

Ein Programm, welches das verdeutlicht:
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdint.h>

int main(int argc, const char* argv[])
{
int bit = 60;
uint64_t ui64;
printf("sizeof(int)=%d\n", (int)sizeof(int));

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<60); /* Keine Wirkung bei sizeof(int) < 8 */
/* gcc warnt sogar:
* gcc -Wall bit_clear.c -o bit_clear
* bit_clear.c: In function ‘main’:
* bit_clear.c:11:5: warning: left shift count >= width of type [enabled by default]
*/
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~((uint64_t)1<<60); /* ok */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1LL<<60); /* auch ok, und kürzer. */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

ui64 = 0xFFFFFFFFFFFFFFFF;
ui64 &= ~(1<<bit); /* Ohne Warnung, und funktioniert manchmal, je nach Optimierung */
printf("%d\n", ui64!=0xFFFFFFFFFFFFFFFF);

return 0;
}
/* Ausgabe auf meinem PC ohne Optimierung:
* sizeof(int)=4
* 0
* 1
* 1
* 1
* Ausgabe auf meinem PC mit -O2
* 0
* 1
* 1
* 0
*/
</syntaxhighlight>

=== Niederwertigstes gesetztes Bit löschen (Standard C) ===

Folgender Code löscht von allen 1-Bits in einer Integer-Variable das niederwertigste, unabhängig von der Position desselben.

Beispiel: 01101000 -> 01100000

<syntaxhighlight lang="c">
uint8_t byte;

byte = irgendwas();

byte = byte & (byte - 1); /* Diese seltsame Operation löscht das
niederwertigste 1-Bit */
</syntaxhighlight>
Beispiel:
<syntaxhighlight lang="c">
Byte : 01101000
Byte-1: 01100111
Ergebnis:01100000

</syntaxhighlight>
Das funktioniert also mit jeder beliebigen Zahl.

Dies kann bspw. zur schnellen Paritätsgenerierung eingesetzt werden:

<syntaxhighlight lang="c">
uint8_t pareven(uint8_t byte) {
uint8_t par = 0;

while(byte) {
byte = byte & (byte - 1);
par = ~par;
}
return par;
}
</syntaxhighlight>

Das genannte gilt natürlich nicht nur für 8-Bit-Integers, sondern für beliebige, vom Compiler unterstützte Wortlängen.

== Bits invertieren ==

Im allgemeinen Sprachgebrauch oft Toggeln genannt (aus dem Englischen). Wenn in einem Byte mehrere [[Digitaltechnik|Bits]] invertiert (getoggelt) werden sollen, wird dies durch eine [[AVR-Tutorial:_Logik#XOR_.28Exlusives_Oder.29 | XOR]]-Verknüpfung erreicht. Alle Bits, welche in der Bitmaske '1' sind, werden invertiert. Alle Bits, die in der Maske auf '0' gesetzt sind, bleiben unverändert.

=== AVR Assembler ===

Bei [[AVR]]s erlaubt dies folgender Assemblercode. Hier wird ein Ausgangspin invertiert.

<syntaxhighlight lang="avrasm">
sbic PortB, 0 ; Überspringe den nächsten Befehl, wenn das Bit 0 im Port gelöscht ist
rjmp ClrBitNow ; Springe zu ClrBitNow
sbi PortB, 0 ; Setze Bit 0 in PortB
rjmp BitReady ; Springe BitReady
ClrBitNow:
cbi PortB, 0 ; Lösche Bit 0 in PortB
BitReady:
</syntaxhighlight>

Noch kürzer gehts so: 
Die zweite Zeile mit dem Befehl '''ldi''' lädt die Bitmaske, in welcher die zu toggelnden Bits auf '1' gesetzt sind. In diesem Beispiel wird das dritte Bit invertiert. Der Vorteil dieser Methode ist neben der Kürze und Übersichtlichkeit auch die Möglichkeit, bis zu 8 Bit gleichzeitig zu toggeln. Diese Methode ist natürlich auch auf normale Daten anwendbar, nicht nur auf IO-Ports.

<syntaxhighlight lang="avrasm">
in R24, PORTE ; Daten lesen
ldi R25, 0x04 ; Bitmaske laden, hier Bit #2
eor R24, R25 ; Exklusiv ODER
out PORTE, R24 ; Daten zurückschreiben
</syntaxhighlight>

Eine andere Möglichkeit gibt es, wenn man nur das 8. Bit kippen will:

<syntaxhighlight lang="avrasm">
in r16, PORTB
subi r16, 0x80
out PORTB, r16
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
PORTB ^= (1<<PB0); /* XOR, Kurzschreibweise, PORTB = PORTB ^ (1<<PB0) */
</syntaxhighlight>

=== Neuere ATmegas ===

Bei den neueren ATmegas (z. B. ATmega48) kann man IO-Pins direkt ohne den Umweg über Register togglen, indem man das entsprechende Bit im PINx-Register '''setzt''':

<syntaxhighlight lang="avrasm">
sbi PIND, 2 ; Bit 2 von Port D togglen
</syntaxhighlight>

=== 8051er ===

<syntaxhighlight lang="avrasm">
cpl bitadresse
</syntaxhighlight>

== Bits prüfen ==

Will man prüfen ob ein oder mehrere Bits in einer Variable gesetzt oder gelöscht sind, muss man sie mit einer Bitmaske UND verknüpfen. Die Bitmaske muss an den Stellen der zu prüfenden Bits eine '1' haben, an allen anderen eine '0'.

* Ist das Ergebnis gleich Null, sind alle geprüften Bits gelöscht.
* Ist das Ergebnis ungleich Null, ist mindestens ein geprüftes Bit gesetzt.
* Ist das Ergebnis gleich der Bitmaske, sind alle geprüften Bits gesetzt.

=== AVR Assembler ===

Der AVR hat spezielle Befehle um direkt einzelne Bits in den CPU-Registern r0..r31 sowie den IO-Registern 0..0x1F zu prüfen.

<syntaxhighlight lang="avrasm">
; Befehle zur Prüfung von einzelnen Bits

sbrs r16,3 ; überspringe den nächsten Befehl, wenn in r16 Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbrc r16,5 ; überspringe den nächsten Befehl, wenn in r16 Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

sbis timsk,3 ; überspringe den nächsten Befehl, wenn in timsk Bit #3 gesetzt ist
rjmp bit_ist_nicht_gesetzt

sbic timsk,5 ; überspringe den nächsten Befehl, wenn in timsk Bit #5 gelöscht ist
rjmp bit_ist_nicht_geloescht

; Befehle zur Prüfung von mehreren Bits

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
breq alle_bits_sind_geloescht

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
brne mind_ein_bit_ist_gesetzt

andi r16,0b1010 ; prüfe Bit #1 und #3 in r16
cpi r16,0b1010
breq alle_bits_sind_gesetzt
</syntaxhighlight>

=== Standard C ===

<syntaxhighlight lang="c">
// prüfe ob Bit 4 in der Variable tmp gelöscht ist
// die Klammer ist wichtig
if (!(tmp & 0x10)) {
// hier die Anweisungen, wenn das Bit gelöscht ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gelöscht sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0) {
// hier die Anweisungen, wenn beide Bits gelöscht sind
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gesetzt ist
}

// prüfe ob Bit 0 oder Bit 4 in der Variable tmp gelöscht sind
if (~tmp & 0x11) {
// hier die Anweisungen, wenn mindestens ein Bit gelöscht ist
}

// prüfe ob Bit 4 in der Variable tmp gesetzt ist
if (tmp & 0x10) {
// hier die Anweisungen, wenn das Bit gesetzt ist
}

// prüfe ob Bit 0 und Bit 4 in der Variable tmp gesetzt sind
// die Klammer ist wichtig!
if ((tmp & 0x11) == 0x11) {
// hier die Anweisungen, wenn beide Bits gesetzt sind
}
</syntaxhighlight>

== Hilfsfunktionen zur Bitmanipulation in C/C++ ==
Um "einfacher" elementare Bitmanipulationen durchzuführen bietet es sich an einige Hilfsfunktionen zu definieren. Dabei gibt es zwei verschiedene Möglichkeiten diese zu realiseren:
* Als C-Makro [[C_Makros]]
* Als Inline-Funktion
In beiden Fällen wird bei eingeschalteter Optimierung letztendlich vom Compiler ein sehr kompakter (und identischer!) Code erzeugt, jedoch ist dringend von der Verwendung von Makros abzuraten (siehe [[Makro]] )!
Im Fehlerfall zeigt der Compiler bei der Verwendung vom Makros keine eindeutigen Fehlermeldungen an, da es sich um simple Ersetzungen handelt - bei der Verwendung von Inline-Funktionen hingegen gibt es eine "brauchbare" Fehlermeldung!

=== Beispiele - Inline Variante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen über Pointer
// PORTA, PB2 setzen
BIT_SET(&PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(&PORTC, PB0);

// PORTA, PB2 direkt setzen
// HIGH
BIT_BOOL_SET(&PORTA, PB2, 1);

// LOW
BIT_BOOL_SET(&PORTA, PB2, 0);
</syntaxhighlight>

=== Beispiele - MakroVariante ===
<syntaxhighlight lang="c">
// Achtung: Zugriffe erfolgen direkt über die Variablen/Portnamen
// PORTA, PB2 setzen
BIT_SET(PORTA, PB2);

// PORTC, PB0 löschen
BIT_CLEAR(PORTC, PB0);
</syntaxhighlight>

Um die Hilfsfunktionen verwenden zu können einfach folgenden Code in eine neue Header-Datei (z.B. BitIO.h) kopieren:

=== Hilfsfunktionen als Inline-Methoden ===
Achtung: Wenn nur ein C Compiler verwendet wird, kennt dieser den Typ "bool" nicht, dieser muss dann vorher definiert werden!
<syntaxhighlight lang="c">
/**
* BitIO.h
* @author Andi Dittrich <http://andidittrich.de>
* @version 1.0
* @license MIT Style X11 License
*/

#include <inttypes.h>

#ifndef BITIO_H_
#define BITIO_H_

// set bit
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_SET(volatile uint8_t *target, uint8_t bit){
*target |= (1<<bit);
};

// set clear
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_CLEAR(volatile uint8_t *target, uint8_t bit){
*target &= ~(1<<bit);
};

// bit toogle
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit) __attribute__((always_inline));
static inline void BIT_TOGGLE(volatile uint8_t *target, uint8_t bit){
*target ^= (1<<bit);
};

// set bit by boolean
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable) __attribute__((always_inline));
static inline void BIT_BOOL_SET(volatile uint8_t *target, uint8_t bit, bool enable){
if (enable){
BIT_SET(target, bit);
}else{
BIT_CLEAR(target, bit);
}
};

#endif /* BITIO_H_ */

</syntaxhighlight>

=== Hilfsfunktionen als C-Makro (nicht empfohlen) ===
<syntaxhighlight lang="c">
/* Bit setzen */
#define set_bit(var, bit) ((var) |= (1 << (bit)))

/* Bit löschen */
#define clear_bit(var, bit) ((var) &= (unsigned)~(1 << (bit)))

/* Bit togglen */
#define toggle_bit(var,bit) ((var) ^= (1 << (bit)))
</syntaxhighlight>

== Bitmanipulation beim MSP430 ==

Beim MSP430 und dessen Compilern sind die Bitnamen meist anders definiert. Und zwar nicht als Bitnummer, sondern als Bitmuster. Darum schreibt man dort die Bitzugriffe in C anders. Das kann auch bei anderen Mikrocontrollern bzw. C-Compilern so sein. Wichtig ist, dass man seine eignen Definitionen in der gleichen Weise wie der Compiler anlegt, um Verwirrung zu vermeiden, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]

<syntaxhighlight lang="c">
// Definition von Bitnamen in den Headerfiles des Compilers

#define PD4 4 // Definition im AVR GCC als Bitnummer
#define PD5 5

#define P14 (1<<4) // Definition im MSP430 GCC als Bitmuster
#define P15 (1<<5)

// Bitmanipulation im Programm

DDRD = (1<<PD5) | (1<<PD4); // AVR GCC
P1DIR = P15 | P14; // MSP430 GCC
</syntaxhighlight>

==Siehe auch==

* [http://www.mikrocontroller.net/topic/179566#1729219 Forumsbeitrag:] Bits aus einem Array extrahieren
* [http://www.mikrocontroller.net/topic/169509#1631439 Forumsbeitrag:] Bits für ein Schieberegister zusammenstellen, TLC5941
* [http://www.mikrocontroller.net/topic/353071?goto=3947567#3947567 Forumsbeitrag:] TLC5947 und ATmega16 Bitmanipulation
* [http://www.mikrocontroller.net/topic/15466?goto=107726#107720 Forumsbeitrag:] Bitreihenfolge ändern
* [http://www.mikrocontroller.net/topic/23866?goto=new#177674 Forumsbeitrag:] Wie drehe ich eine Bitreihenfolge um?
* [http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/AVR-Built_002din-Functions.html AVR Build-in Functions], spezielle Funktion im avr-gcc zur schnellen Bitvertauschung, engl.

[[Category:8051]]
[[Category:AVR-Arithmetik]]

MMC- und SD-Karten

2014-02-19T21:18:36Z

Mthomas: /* DOs und DON'Ts bei der Ansteuerung */

MMC- und SD-Speicherkarten lassen sich im [[SPI]]-Modus relativ einfach mit einem Mikrocontroller ansteuern. Prinzipiell gibt es zwischen SD-Card und MMC nicht viele Unterschiede, allerdings sind SD-Karten weiter verbreitet, in der Regel schneller als MMCs, und haben ein besser implementiertes SPI-Interface. Es existieren diverse Varianten (miniSD, microSD), die zur normalen SD-Card weitgehend kompatibel sind.

Die Karte liest das anliegende Datenbit mit der steigenden Taktflanke ein, als SPI-Modi eignen sich somit Mode 0 (CPOL=0, CPHA=0) und Mode 3 (CPOL=1, CPHA=1) (siehe auch [[Serial Peripheral Interface]]). Bei MMCs ist der SPI-Modus nicht genau spezifiziert, somit kommt es durchaus mal vor dass der SPI-Modus je nach Karte unterschiedlich gewählt werden muss, oder dass die Karte überhaupt nicht zuverlässig funktioniert (siehe [http://www.mikrocontroller.net/forum/read-1-343528.html Beitrag im Forum]).

== DOs und DON'Ts bei der Ansteuerung ==

* '''Lasst euch nicht verrückt machen''' wenn es einfach nicht funktioniert, sondern probiert zu allererst mal eine SD-Karte eines anderen Herstellers aus. Die MMC-Implementierung für AVR von Elm Chan z. B. funktioniert mit SanDisk problemlos hat aber mit Platinum Karten ein Problem.
* Taktfrequenz bei der Initialisierung nicht höher als 400kHz
* Ein Pullup-Widerstand am Ausgang der MMC/SD Karte (DO) ist für eine saubere Initialisierung per SPI notwendig! [http://www.mikrocontroller.net/topic/112421#1001693 (Thread mit Erklärung dazu)]
* Ein Pullup-Widerstand an der Select-Leitung (/CS) schadet nicht und stellt sicher, dass die Karte erst mit Absicht selektiert wird.
* Nachdem die Karte deselektiert wurde (/CS auf high), die Taktleitung noch einige Male pulsen, damit die Karte DO hochohmig/tri-state schaltet (vgl. Chans Erläuterungen).
* Im SPI-Mode die nicht benutzten SD-Datenleitungen mit Pull-Ups versehen ([http://www.mikrocontroller.net/topic/86311#763460])
* Saubere Versorgung: Kein Dioden-Pfusch, mit dem eine vorhandene 5V Versorgung mittels in Reihe geschalteter Dioden auf irgendwas im Bereich 3V "geregelt" wird. Stattdessen einen guten 3,3V-Regler verwenden. Die Karte mag es nicht, wenn mehr als 60mV Ripple auf Vcc ist. LM317 oder LM1117-ADJ/-3.3 mit entspechenden Kondensatoren reicht zumindest bei Basteleien allemal.
* Sauberer Anschluss der Digitalschnittstelle: Spannungsteiler "verschleifen" die Signale bei hohen Frequenzen und die Übertragungsrate muss dann begrenzt werden. Also entweder ein [http://www.mikrocontroller.net/articles/Pegelwandler Pegelwandler] oder gleich an ein 3,3V I/O anschließen.
* Die Karten verfügen weder über einen Reset- noch einen Sleep-Anschluss. Moderne Karten reduzieren bei Nichtbenutzung ihren Stromverbrauch, einen vollständigen Reset kann man jedoch nicht per Software auslösen. Daher sollten die Karten per P-Channel-FET oder Spannungsregler/-wandler mit Enable-Funktion so angeschlossen werden, dass über Versorgung an/aus ein (Power-On-)Reset ausgelöst werden kann. Dabei darauf achten, dass vorhandene Pull-Up-Widerstände bei abgeschalteter Versorgung ebenfalls deaktiviert werden (vgl. z. B. Schaltplan für den Anschluss von SD-Card/MMC per SPI an AVR in Chans Beispielen. Link unten).
* Ist beabsichtigt die Speicherkarte im Betrieb auszutauschen, sollte darauf geachtet werden, dass einige Karten beim Einstecken einen relativ hohen Strombedarf haben. Dies kann einen kurzzeitigen Zusammenbruch der Spannungsversorgung verursachen, der zu undefinierten Zuständen führt (z. B. Reset eines Mikrocontrollers durch Ansprechen des Unterspannungsschutzes/Brown-Out-Detection). Abhilfe schafft eine Spule in Reihe zum Versorgungsanschluss (VDD) der Karte. In vielen Boards von Olimex werden dazu 470 nH Festinduktivitäten verwandt.
* Guter Kontakt im Steckplatz, sehr gut eignen sich mit der Zange verbogene Stiftleisten, oft sieht es aus als ob es "passt", aber es gibt doch keinen Kontakt, daher bei Fehlern: Immer Durchmessen! Auch zu erwähnen wären da alte ISA-Bus Buchsen, die auf jedem alten PC Mainboard drauf sind. Um sicher zu gehen, dass der Kontakt wirklich gut ist, sollte man aber trotzdem SD-Slots benutzen. Diese bekommt man u.a. bei CSD (günstig), Reichelt (teuer) oder aus alten Kartenlesern.
* Guter Kontakt #2: Was sich im übrigen auch sehr gut eignet sind Adapter von MiniSD auf normales SD-Format, um dann MiniSD zu benutzen. Wenn man eine Stiftleiste im 2.54mm-Format oder Lötnägel im selben Format auf der Platine hat, kann man daran wunderbar den SD-Kartenadapter anlöten. Das ist mechanisch recht stabil. Ein kleines Manko ist allerdings, daß dann eine Gold-Lötzinn-Legierung durch die vergoldeten Kontakte entsteht und das soll ja dem Lötzinn langfristig nicht sehr zuträglich sein. Aber für's Hobby funktioniert das wunderbar.
* '''Speziell PIC''': Wird der C18 Compiler benutzt, so hat man in der Bibliothek die Funktion ReadSPI(). Diese darf nicht benutzt werden, da sie SSPBUF vor dem Lesevorgang mit 0x00 initialisiert. Die SD-Karte erwartet aber 0xff !! Man kann die Funktion aus der Bibliothek kopieren und SSPBUF = 0xff schreiben, dann gehts.

{| border="0"
|-
||[[Bild:SD Steck Stift.jpg]] 
(Liefere Bild in besserer Qualität nach!)
|}

== Bibliotheken zur Ansteuerung ==

* [http://elm-chan.org/fsw/ff/00index_e.html ELM ChaN FatFs] FAT(12,16,32)-Dateisystem. Klein und übersichtlich, hochoptimiert, frei auch für kommerzielle Anwendung. Beispiele für AVR, H8, LPC2k mit MCI u.a. enthalten ("samples"), neuere Versionen mit LFN-Unterstützung. Beispiel für AT91SAM7 inkl. DMA im Projekt [[ARM MP3/AAC Player]]. (siehe auch [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/ M. Thomas' ARM+SD/MMC Seite])
* [http://elm-chan.org/fsw/ff/00index_p.html ELM ChaN Petit FatFS] FAT(12,16,32)-Dateisystem. Sehr klein. Beispiele für AVR.
* [http://sourceforge.net/projects/efsl EFSL] FAT16/32-Dateisystem, unterstützt Partitionen und Superfloppys, Beispielcode für AVR, LPC2000 und AT91SAM7 enthalten (siehe auch [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/ M. Thomas' ARM+SD/MMC Seite])
* [http://www.holger-klabunde.de/avr/avrboard.htm#cf Holger Klabundes FAT16/32] mit Beispielen für AVR MMC/SD und CF, LPC2k mit SPI
* libfat aus dem [http://sourceforge.net/projects/devkitpro devkitpro-Projekt] u.a. LFN-Unterstützung.
* [http://www.mikrocontroller.net/forum/read-4-125350.html MMC-Ansteuerung mit FAT16 von Ulrich Radig]
* [http://www.zws.com/products/dosfs/index.html DOSFS Free FAT12/FAT16/FAT32 Filesystem] "DOSFS is a free FAT-compatible filesystem intended for fairly low-end embedded applications. Intended target systems would be in the ballpark of 1K RAM, 4K ROM or more".
* [http://www.mikrocontroller.net/topic/48481 MMC/SD-Karte mit FAT16 an AVR] von Roland Riegel
* [ftp://ftp.circuitcellar.com/pub/Circuit_Cellar/2005/176/Sham176.zip Circuit Cellar FAT16 MMC/SD] mit MMC/SD Hardwaretreiber für MSP430
* [http://www.analog.com "Implementing FAT32 File Systems on ADSP-BF533 Blackfin Processors"] Application Note und Code von ADI
* [http://www.atmel.com/dyn/products/tools.asp?family_id=682 FAT-Code in Atmel's AVR32 UC3 Software-Library]
* [http://www.mikrocontroller.net/articles/FAT32 AVR FAT16/32] Bibliothek mit Wiki. Unterstützt LFN und Ordner Rekursiv löschen. SVN für neuste Version.
* [http://www.embedded-os.de/index.html?pcfat_port.htm pC/FAT driver] "using SPI for sector read/write to MMC/MMCplus/HD-MMC/M-Bridge/SD/SDHC-cards on different platforms"
* [http://www.dharmanitech.com/2009/01/sd-card-interfacing-with-atmega8-fat32.html SD Card Interfacing with ATmega8] (FAT32 implementation) by CC Dharmani
* [http://www.blacksphere.co.nz/main/openfat OpenFAT]: "OpenFAT is a FAT filesystem implementation intended for use with embedded microcontrollers in small systems. (...) OpenFAT is licensed under the GPL, version 3."

== Allgemeine Informationen ==

* [http://www.digitalspirit.org/file/index.php/obj/docs/sd/ Datenblätter] ( [http://www.digitalspirit.org/file/index.php/obj-download/docs/sd/ProductManualSDCardv2.2final.pdf SD Card Product Manual 2.2] )
* [http://elm-chan.org/docs/mmc/mmc_e.html ELM ChaN - How to Use an MMC]
* [http://elm-chan.org/fsw/ff/00index_e.html ELM ChaN - FatFs Generic FAT File System Module]
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=MMC*+SD Beiträge zum Thema MMC/SD im Forum (ca. 200 Threads)]
* [http://www.shop.display3000.com/elektronikmodule/sd-speicherkartenplatine.html Weiter unten im Text (runterscrollen) gibt es interessante Oszi-Bilder zu den oft genannten Spannungsteilern oder Transistorlösungen als Pegelwandler]
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en547784 Microchip Memory Disk Drive System mit FAT32 und SDHC Unterstützung]
* [http://www.ifas.htwk-leipzig.de/easytoweb/download/D&E_11_2006_Anbindung_von_SD-Karten.pdf Gute Beschreibung der SDIO-Architektur und wie man eine SD-Karte mit ARM bzw. AVR benutzt]

== Bauteile ==

* [http://www.instructables.com/id/EZD6Q18LYGES1762SJ/ DIY SD-Card Fassung aus einem alten Floppy Kabel]
* [http://www.watterott.com/index.php?page=search&page_action=query&desc=on&sdesc=on&keywords=multicomp&x=0&y=0 Halter für SD-Karten]
* [http://www.shop.display3000.com/elektronikmodule/sd-speicherkartenplatine.html günstige Komplettlösung mit bidirektionalem Pegelwandler, Spannungsregler, Kartenhalter]

== Projekte ==

* [http://retromaster.wordpress.com/ufe/ Ultimate Floppy Emulator] von Retromaster (PIC32 @ 80 Mhz, 16 Mb SDRAM)

[[Category:Bauteile]]
[[Category:Datenübertragung]]
[[Kategorie:Speicher und Dateisysteme]]

ARM Cortex Mikrocontroller

2013-12-08T23:15:30Z

Mthomas: /* IDEs */

Die Firma ARM stellt selbst keine Prozessoren/Controller her, sondern entwickelt nur sogenannte "IP-Cores", die von Herstellern wie Atmel, Infineon, NXP, TI und vielen anderen lizenziert werden. Diese Hersteller ergänzen den Core um Speicher und Peripherie. Der Vorteil dieses Modells ist, dass dadurch sehr viele Prozessoren mit unterschiedlichster Ausstattung verfügbar sind, die alle mit dem selben Befehlssatz (und damit dem selben Compiler) programmierbar sind.

'''In diesem Artikel geht es NUR um die ARM Cortex-M Microcontroller, nicht jedoch um ARM [https://www.mikrocontroller.net/articles/Cortex-A Cortex-A] Prozessoren.'''

=== Befehlssatz ===
Allen ARM-Cores gemeinsam ist die 32 Bit RISC-Architektur. Manche ARM-Cores besitzen neben dem 32 Bit ARM-Befehlssatz noch einen zusätzlichen, kleineren 16 Bit-Befehlssatz ('''Thumb'''-Modus, erkennbar am '''T''' in der Bezeichnung, z. B. ARM7'''T'''DMI). Der Vorteil des Thumb-Befehlssatzes ist der geringere Platzbedarf des Codes; der Nachteil ist die etwas niedrigere Geschwindigkeit. Die ARMv7M-Architektur (man beachtet das '''v'''), also z. B. Controller mit Cortex-M3-Kern, unterstützen ausschließlich den Thumb2-Befehlssatz.

== ARM Cortex M ==

Seit wenigen Jahren sind ARM-basierte Mikrocontroller erhältlich, die Aufgrund der vergleichbar einfachen Beschaltung und mit einer '''deutlich''' größeren Power eine echte Alternative zu 8-Bit-Controllern darstellen.

Es gibt folgende Varianten dieses Mikrocontroller "Kerns",
aufgeführt vom Energieeffizientesten zum Leistungsfähigsten:

=== ARM Cortex M0 ===
Als günstigere Variante gibt es die Cortex-M0 Cores mit deutlich kleinerem Befehlssatz, wie z.B. den '''[[LPC1xxx]]'''. Diese
werden beispielsweise in folgenden Controllern eingesetzt:

* [http://www.st.com/internet/mcu/subclass/1588.jsp?WT.ac=fp_may12_stm32f0 STM32F0] von [http://www.st.com STMicro], siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://ics.nxp.com/products/lpc1000/lpc11xx/ LPC11xx] von [http://www.nxp.com NXP], siehe '''[[LPC1xxx|LPC1xxx hier im Wiki]]'''
* [http://www.infineon.com/XMC1000 XMC1000] von [http://www.infineon.com Infineon], siehe '''[[XMCxxxx|XMCxxxx hier im Wiki]]'''
* [http://www.nuvoton.com/NuvotonMOSS/Community/ProductInfo.aspx?tp_GUID=5dbf7d7a-b6df-4fe1-91c9-063449500ce7 NuMicro-Controller] von nuvoton (ex Winbond), laut Datenblatt mit 2.5-5.5V Betriebssspannung!!!
Für die M0-Familie ist für den LPC1xxx bereits eine '''[http://www.mikrocontroller.net/articles/Codebase_f%C3%BCr_LPC1xxx#Allgemeine_Informationen_zum_Aufbau_der_Code_Base Code-Base]''' und ein preisgünstiges '''[http://www.mikrocontroller.net/wikisoftware/index.php?title=LPC1xxx_Entwicklungskit_LPCXpresso Entwicklungskit]''' vorhanden.

=== ARM Cortex M0+ ===
Inzwischen gibt es auch eine optimierte Version des Cortex-M0 - die Cortex-M0+ Cores. Diese können (optional) einige Features der Cortex-M3 Serie beeinhalten, wie z.B eine MPU:

* [http://www.energymicro.com/products/efm32-zero-gecko-microcontroller-family EFM32 Zero Gecko] von [http://www.energymicro.com Silicon Labs (ehemals Energy Micro)], siehe '''[[EFM32|EFM32 hier im Wiki]]'''
* [http://www.nxp.com/products/microcontrollers/cortex_m0plus/lpc800/ LPC8xx] von [http://www.nxp.com NXP]
* [http://www.freescale.com/webapp/sps/site/taxonomy.jsp?code=KINETIS_L_SERIES Kinetis L-Serie] und [http://www.freescale.com/webapp/sps/site/taxonomy.jsp?code=KINETIS_M_SERIES Kinetis M-Serie] von [http://www.freescale.com/ Freescale]
* [http://www.fujitsu-fm-family.com/products/fm0.html angekündigte FM0+ Familie] von [http://www.fujitsu.com/emea/services/microelectronics Fujitsu]

=== ARM Cortex M3 ===
Eine sehr aktuelle Variante des ARM ist die Cortex-M3 Familie die '''[[LPC1xxx]]''', als eine echte Konkurrenz zu 8- und 16-Bit Mikrocontrollern wie dem [[AVR]] und [[MSP430]] gedacht ist. Der Cortex-M3 enthält einige Verbesserungen gegenüber dem ARM7TDMI-Kern und ist bereits dabei diesen zu ersetzen.
Controllerfamilien dieser Klasse sind:

* [http://www.energymicro.com/products/efm32-tiny-gecko-microcontroller-family EFM32 Tiny Gecko],[http://www.energymicro.com/products/efm32-gecko-microcontroller-family EFM32 Gecko] sowie [http://www.energymicro.com/products/efm32-leopard-gecko-microcontroller-family EFM32 Leopard Gecko] von [http://www.energymicro.com Silicon Labs (ehemals Energy Micro)] , siehe '''[[EFM32|EFM32 hier im Wiki]]'''
* [http://www.nxp.com LPC13xx/LPC17xx/LPC18xx] von NXP oder die inzwischen schon sehr ausführliche, siehe '''[[LPC1xxx|LPC1xxx hier im Wiki]]'''
* [http://www.ti.com/lsds/ti/microcontroller/tiva_arm_cortex/c_series/tm4c_arm_cortex-m4/overview.page TIVA] von [http://www.ti.com Texas Instruments] (vormals Stellaris, vormals Luminary Micro)
* [http://www.atmel.com/products/at91/sam3landing.asp?family_id=605 AT91SAM3] von Atmel
* [http://www.st.com/internet/mcu/family/141.jsp STM32] Baureihen [http://www.st.com/internet/mcu/subclass/1169.jsp F1]/[http://www.st.com/internet/mcu/subclass/1520.jsp F2]/[http://www.st.com/internet/mcu/subclass/1376.jsp L1]/[http://www.st.com/internet/mcu/subclass/1377.jsp W] von STMicroelectronics , siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://www.toshiba-components.com/microcontroller/TMPM330.html TMPM330] von Toshiba
* [http://www.spansion.com/Products/microcontrollers/32-bit-ARM-Core/fm3/Pages/FM3-family.aspx FM3] von [http://www.spansion.com Spansion] (vormals Fujitsu)
* [http://www.infineon.com/XMC4000 XMC4000] von Infineon, siehe '''[[XMCxxxx | XMC hier im Wiki]]'''
* [https://www.silabs.com/products/mcu/Pages/ARM-32bit-microcontroller.aspx SiM3U1xx] von Silabs
* [http://www.holtek.com.tw/english/products/32bit_flashmcu.htm HT32] von Holtek Semiconductor

Für den LPC1xxx ist bereits eine '''[http://www.mikrocontroller.net/articles/Codebase_f%C3%BCr_LPC1xxx#Allgemeine_Informationen_zum_Aufbau_der_Code_Base Code-Base]''' und ein preisgünstiges '''[[LPC1xxx_Entwicklungskit_LPCXpresso]]''' vorhanden.

=== ARM Cortex M4 ===
Als hoch performante Variante gibt es dann noch die Cortex-M4 Cores welche teilweise mit einer FPU ausgestattet sind.

Diese werden beispielsweise in folgenden Controllern eingesetzt:

* [http://www.energymicro.com/products/efm32-wonder-gecko-microcontroller-family EFM32-Wonder Gecko] von [http://www.energymicro.com Silicon Labs (ehemals Energy Micro)], siehe '''[[EFM32|EFM32 hier im Wiki]]'''
* [http://www.nxp.com LPC43xx] von NXP (Dual Core)
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3] von [http://www.st.com STMicro], siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://www.st.com/internet/mcu/subclass/1521.jsp?WT.ac=p2_bn_jun12_stm32f4series STM32F4] von [http://www.st.com STMicro], siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://www.ti.com/lsds/ti/microcontroller/tiva_arm_cortex/c_series/tm4c_arm_cortex-m4/overview.page Tiva C Series, TM4C] von [http://www.ti.com Texas Instruments]. Früher nannte Texas Instruments diese Controller ''Stellaris LM4F Series''. 2013 begann TI mit einer große Umbenennung, bei der sogar neue Typenbezeichnung vergeben wurden. So wurde zum Beispiel aus dem LM4F230H5QR der TM4C123GH6PM. Gleichzeitig begann TI die Bezeichnung ''Stellaris'' aus Datenblättern, Software-Bibliotheken und Ähnlichem zu entfernen und durch ''Tiva'' zu ersetzen. Siehe auch [http://www.ti.com/lit/an/spma050a/spma050a.pdf].
* [http://www.infineon.com/XMC4000 XMC4000] von [http://www.infineon.com Infineon], siehe '''[[XMCxxxx|XMCxxxx hier im Wiki]]''', [https://www.mikrocontroller.net/articles/XMC4500 Artikel zum XMC4500]
* [http://www.spansion.com/Products/microcontrollers/32-bit-ARM-Core/fm4/Pages/default.aspx FM4] von [http://www.spansion.com Spansion] (vormals Fujitsu)
* [http://www.atmel.com/products/at91/sam4landing.asp?family_id=605 AT91SAM4] von Atmel

== ARM7 ==
Eine schon etwas ältere Controller-Familie ist der '''ARM7'''TDMI. Core. Controllerfamilien dieser Klasse sind:
* NXP (ehemals Philips) [[LPC2000]]
* Atmel [[AT91SAM]]7
* Analog Devices [[ADuC7xxx]]
* [http://focus.ti.com/mcu/docs/mcuprodoverview.tsp?sectionId=95&tabId=203&familyId=454 Texas Instruments TMS470]
* SAMSUNG S3C24x0 [http://www.samsung.com/global/business/semiconductor/productInfo.do?fmly_id=229&partnum=S3C2410]
* STR7xx von ST Microelectronics [http://www.st.com/mcu/inchtml-pages-str7.html]
* und viele weitere

Mehr Informationen zur ARM-Architektur finden sich in der [http://de.wikipedia.org/wiki/ARM-Architektur Wikipedia], weiterführende Links in der [[Linksammlung#ARM|Linksammlung]].

== Compiler ==

=== Basic ===
Von Mikroe gibt es Basic
http://www.mikroe.com/mikrobasic/arm/

=== Pascal ===
Von Mikroe gibt es Pascal
http://www.mikroe.com/mikropascal/arm/

=== [[ARM_GCC|GCC]] ===

Einer der beliebtesten Compiler für ARM-Prozessoren ist der GCC. Er kann sowohl ARM- als auch Thumb-Code erzeugen. Mehr dazu unter [[ARM GCC]].

=== IDEs ===

Kostenlose Entwicklungsumgebungen:
* [http://www.coocox.org/CooCox_CoIDE.htm CooCox IDE] (Eclipse basierend)
* Für das MBED Board (mbed NXP LPC1768) ist ein kostenloser Onlinecompiler verfügbar (ARM Realview), der sich durch die Bereitstellung von sehr leistungsfähigen Funktionen (API's) auszeichnet. Den praktischen Nutzen für eine professionelle Anwendung mag man zu Recht in Frage stellen. Um mal schnell was zu programmieren ist das Ding unschlagbar, es ist faktisch keine Installation oder Einarbeitung in eine IDE nötig.
* [http://www.emide.org/ emIDE] Windows, komplette Visual Studio artige Entwicklungsumgebung (basierend auf Code::Blocks) mit GCC und Debugger (Unterstützung für Adapter von Segger) 
* [http://www.isystem.com/products/software/winidea-open winIDEAOpen]
* Die Fa. iSystem stellt mit der winIDEAOpen nun eine kostenlose Entwicklungsumgebung für alle Cortex-M Bauteile zur Verfügung. Als Compiler wird der GNU GCC verwendet und auch gleich mitinstalliert. Die IDE ist recht intuitiv und mit einer umfangreichen Hilfe ausgestattet. Das Ganze funktioniert mit dem GCC ohne Codesize Limit und auch ein Testwerkzeug (testIDEA) ist mit integriert. Hardwareseitig werden neben dem iSystem iTag50 [http://www.isystem.com/products/hardware/cortex-debugger/itag] auch die Segger J-Link Debug Probes sowie der ST-Link von ST unterstützt. Auf der Webseite von iSystem sind auch einige schöne Beispielprojekte für diverse Boards zu finden [http://www.isystem.com/download/winideaopen]. Demnächst soll noch die Unterstützung für die ARM und IAR Compiler hinzuzkommen. Hier gehts zum ''[http://www.isystem.com/download/winideaopen Download]'''
* Für die LPC Prozessorfamilie ist eine kostenlose C/C++ Entwicklungsumgebung von '''[http://www.code-red-tech.com/lpcxpresso.php code-red]''' erhältlich. Die auf Eclipse basierende Entwicklungsumgebung ist nach der Installation bis 8k freigeschaltet und nach einer einfachen und kostenlosen Registrierung für 128kB. Die IDE ist auch für '''[http://support.code-red-tech.com/CodeRedWiki/redlib_v2_notes Linux]''' verfügbar. Hier die '''[http://www.mikrocontroller.net/articles/Installationsanleitung_C-Entwicklungsumgebung_f%C3%BCr_LPC1xxx_von_Code_Red Installationsanleitung]'''

Kommerzielle Entwicklungsumgebungen (zum Teil kostenlos mit Einschränkungen) für ARM-basierte Mikrocontroller sind z. B. :
*[http://www.code-red-tech.com/red-suite-4-nxp.php Code-Red (Eclipse basierend für mehr als 128k)]
*[http://rowley.co.uk/arm/ Crossworks ARM] (GCC-basiert, Windows, Mac OS und Linux)
* [http://www.cosmicsoftware.com/download_cortex_64k.php Cosmic Software] 64k free (Windows)
* [http://www.iar.com/ewarm/ IAR Embedded Workbench for ARM] (Windows)
* [http://www.keil.com/arm/ MDK-ARM von Keil/ARM] (Windows).

== JTAG/SWD ==

Alle ARM-basierten Prozessoren verwenden ein einheitliches [[JTAG]]-Interface, über das Debugging und Speicherzugriff erfolgen kann. Nicht standardisiert sind allerdings die Verfahren zum Beschreiben des Flash-ROMs, deshalb muss man beachten ob die verwendete JTAG-Software Programmierroutinen für den jeweiligen Controller besitzt.

Es gibt Mikrocontroller (z.B. [[EFM32]] von [https://www.energymicro.com Energy Micro]) welche NUR über SWD (Serial Wire Debugg) programmiert werden können.

=== Günstige Beispiele zum Starten ===
Ein einfacher JTAG-Adapter für den Parallelport ist der "Wiggler"-kompatible, den man selbst bauen kann oder z. B. im [http://shop.embedded-projects.net/index.php?module=artikel&action=artikel&id=48 Embedded Projects Shop] für € 10,00 bestellen kann. Als Software lässt sich unter Windows und Linux [http://openocd.berlios.de/ OpenOCD] (zusammen mit [[GDB]]) oder [http://rowley.co.uk Crossworks ARM] verwenden.

Für USB gibt es [http://shop.embedded-projects.net/index.php?module=artikel&action=artikel&id=436 hier] einen ebenfalls OpenOCD-kompatiblen JTAG-Adapter zum Preis von ca 45€.

Von NXP sind preiswerte Entwicklungskits (ca. 25€ für Evaluation-Board incl. USB-JTAG-/-SWD-Programer und Debugger) erhältlich z.B. '''[http://www.watterott.com/index.php?page=search&keywords=LPCXpresso&cat=&mnf=&x=0&y=0 Watterott]'''. Siehe dazu auch die Dokumentation von NXP zu den '''[http://www.nxp.com/documents/leaflet/75016842.pdf LPCXpresso-Entwicklungskits]''' (PDF), oder diese '''[http://www.mikrocontroller.net/wikisoftware/index.php?title=LPC1xxx_Entwicklungskit_LPCXpresso Beschreibung]'''.

Von ST gibt es günstige Entwicklungskits (ca. 20€), mit integriertem ST-Link (Debugger). Zum Beispiel das [http://www.st.com/stm32f4-discovery STM32F4 Discovery Board].

Von Energymicro gibt es [http://www.energymicro.com/tools/efm32-starter-kits Starter Kits] mit integriertem J-Link (Debugger) ab ca. 50 € z.B. das [http://www.energymicro.com/tools/efm32-tiny-gecko-starter-kit EFM32 Tiny Gecko Starter Kit] bei [http://de.mouser.com/ProductDetail/Energy-Micro/EFM32-TG-STK3300/?Energy-Micro/EFM32-TG-STK3300/&qs=sGAEpiMZZMvFPGEOwQcrYyZeaSbmjQvRx7NKUweLQtQ= Mouser]

Der [http://www.segger.com/cms/jlink.html J-Link]-"Emulator" von Segger wird von vielen Softwarepaketen unterstützt und ist für den "nicht-kommerziellen" Einsatz von Studenten, Funkamateuren und Hobby-Bastler für ca. €50.- erhältlich (J-Link-Edu). Sein Umfang ist dabei auf das Flashen des Speichers und das Debuggen beschränkt. Die Trace-Option wie sie bei der PRO-Variante zur Verfügung steht, ist nicht vorhanden. Für den Preis (05/2013) bekommt man jedoch ein ausgewachsenes Werkzeug mit breiter Unterstützung und der Möglichkeit sowohl SWD als auch JTAG in einem Gerät vereint zu haben.

Der ULINK2 von Keil/ARM ist ebenfalls ein wirklich gutes Gerät. Leider ist er nicht ganz so günstig und seine Zusammenarbeit beschränkt sich auf die Arm/Keil IDE µVision. Er benötigt jedoch keine speziellen USB-Treiber sondern nutzt geschickt die Funktionalität der HID-Treiber des Betriebssystems. Das macht ihn sofort auf jedem Windows-Betriebssystem einsatzbereit.

Als Alternative zum Beschreiben des Flash über JTAG ist oft ein serieller [[Bootloader]] im Controller enthalten. Bei ST werden sie über einen speziellen Pin der MPU aktiviert und sind dank Kompression und das intelligente entfernen redundanter Information, bei der Übertragung genauso schnell wie JTAG/SWD Adapter.

== CMSIS - ARM Cortex Software Libraries ==

CMSIS - Cortex Microcontroller Software Interface Standard

Der ARM Cortex Microcontroller Software Interface Standard (CMSIS) ist ein herstellerunabhängiger Hardware Abstraction Layer für die Cortex-M-Prozessor -Serie. Die CMSIS ermöglicht konsistente und einfache Software-Schnittstellen für den Prozessor und die Peripherie, und vereinfacht damit die Software-Wiederverwendung.

Die CMSIS besteht aus folgenden Komponenten:

* CMSIS-CORE: Bietet eine Schnittstelle zum Cortex-M0, Cortex-M3, Cortex-M4, SC000 und SC300-Prozessoren und Peripherie-Register
* CMSIS-DSP: DSP-Bibliothek mit über 60 Funktionen in Festkomma-(fractional q7, q15, q31) und single precision floating-point (32-bit)-Implementierung
* CMSIS-RTOS API: Standardisierte Programmierschnittstelle für Echtzeit-Betriebssysteme für Thread-Steuerung, Ressourcen-und Zeitmanagement
* CMSIS-SVD: System View Beschreibung - XML-Dateien, die die Programmiereransicht des kompletten Mikrocontroller-Systems einschließlich Peripheriegeräte enthalten

Der Standard ist für Cortex-M-Mikrocontroller skalierbar: Von der kleinsten 4 KB MCU bis zu MCUs mit anspruchsvoller Kommunikations-Peripherie wie Ethernet oder USB. Der Speicherbedarf für die Core Peripheral Funktionen bedarf weniger als 1 KB-Code und weniger als 10 Bytes RAM.

Beispiele:

* Software Beispiele von [http://www.energymicro.com/downloads/application-notes Energy Micro] basierend auf CMSIS

Mehr Informationen unter:

* [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php ARM CMSIS Webseite]

== Freie Software ==

=== ARM/XSCALE/CORTEX Instruction Set Simulator ===

Die Firma Lauterbach bietet unter der Artikelnummer LA-8809 einen Instruction Set Simulator für ARM Cores an. Die Demoversion ist zur Evaluierung kostenlos. Einschränkungen bestehen in der Anzahl der zu ladenen Debugsymbole. Der Simulator unterstützt alle gängigen ARM Derivate und lädt alle üblichen Debugformate, wie die des RealView, IAR und TI Compilers, oder der freien GCC Tools.

Zum Simulator gibt es entsprechende zugehörige Debugtools, die allerdings käuflich zu erwerben sind.

Weblinks:
[[http://www.lauterbach.com/frames.html?dwnload.html Download area mit ARM/XSCALE/CORTEX Simulator]]

== Siehe auch ==
* [[Linksammlung#ARM|Linksammlung (Abschnitt ARM)]]
* [http://www.mikrocontroller.net/articles/LPC1xxx Beschreibung der LPC1xxx-Familie]
* [http://www.mikrocontroller.net/articles/LPC1xxx_Entwicklungskit_LPCXpresso LPCXpresso-Entwicklungskit]
* [http://www.mikrocontroller.net/articles/Installationsanleitung_C-Entwicklungsumgebung_f%C3%BCr_LPC1xxx_von_Code_Red Installationsanleitung zur IDE von Code-Red]
* [http://www.mikrocontroller.net/articles/Codebase_f%C3%BCr_LPC1xxx LPC1xxx Codebase]
* [[ARM-elf-GCC-Tutorial]]
* [[AVR32]]
* [[Blackfin]]
* [[AT91SAM9260]]
* [[STM32]]
* [[JTAG]]
* [http://www.mikrocontroller.net/articles/EFM32 EFM32]

== Weblinks ==
* [http://embdev.net/forum/arm-gcc ARM-GCC Forum] im englischsprachigen "Ableger" von microcontroller.net embdev.net u.a. für WinARM, Yagarto, CS Codebench
* [http://infocenter.arm.com/help/index.jsp Infocenter von ARM Ltd.]
* [http://www.open-research.org.uk/ARMuC/ ARMuC ARM microcontroller Wiki]
* [http://chaosradio.ccc.de/cre151.html Chaosradio Express - Die ARM-Architektur]

== Literatur ==
*ARM Systems Developer's Guide (2004) ISBN 1558608745 [http://books.google.de/books?id=HKKUkDQE17QC&output=html Im Buch blättern] [http://www.mkp.com/companions/defaultindividual.asp?isbn=9781558608740 Programmbeispiele aus dem Buch, u.a. FFT, FIR/IIR-Filter, Division, Wurzel]
*ARM Assembly Language - an Introduction (2007) ISBN 1847536964 [http://books.google.de/books?id=8KJX5R8mMvsC&output=html Im Buch blättern] [http://www.lulu.com/content/1172076 Verlagsseite "Book on demand"]
*ARM Rechnerarchitekturen für System-on-Chip-Design (2002) ISBN 3826608542
*Co-Verification of Hardware and Software for Arm Soc Design (2004) ISBN 0750677309
*ARM System-on-Chip Architecture (2000) ISBN 0201675196 [http://books.google.de/books?id=J_Fu_YTVD9gC&printsec=frontcover&output=html&source=gbs_summary_r&cad=0 Im Buch blättern]
*ARM Architecture Reference Manual ISBN 0201737191 [http://books.google.de/books?id=O5G-6WX1xWsC&printsec=frontcover&output=html&source=gbs_summary_r&cad=0 Im Buch blättern]
*Messen, Steuern und Regeln mit ARM-Mikrocontrollern ISBN 3772340172 [http://books.google.de/books?id=TKs4kN-zNYQC&output=html im Buch blättern]
*Programming Arm Microcontrollers: Using C and the Lpc2100 Family (2005? /ab 1. Dezember 2008) ISBN 0321263359
*Arm Assembly: Fundamentals and Techniques (ab 1. März 2009) ISBN 1439806101
*Reliable Embedded Systems: Using 8051 and ARM Microcontrollers (2007) ISBN 0321252918 600 Seiten mit CD [http://vig.pearsoned.co.uk/catalog/academic/product/0,1144,0321252918-TOC,00.html Inhaltsverzeichnis]
* C und C++ für Embedded Systems (u.a. ARM Cortex-M3) mitp-Verlag 2008 ISBN 382665949X
* The Definitive Guide to the Arm Cortex-M0 (Joseph Yiu) Newnes Verlag ISBN 0123854776
* The Definitive Guide to the Arm Cortex-M3 (Joseph Yiu) Newnes Verlag ISBN 185617963X

== Artikel aus der Kategorie ARM ==
<ncl style=compact maxdepth=2 headings=bullet headstart=2
showcats=1 showarts=1>ARM</ncl>
* [http://www.mikrocontroller.net/articles/EFM32 '''EFM32''']

* [http://www.mikrocontroller.net/articles/EFM32 '''XMCxxxx''']

* [https://www.mikrocontroller.net/articles/Cortex-A ARM Cortex A]

[[Category:ARM| ]]

ARM GCC

2013-12-08T23:05:34Z

Mthomas: /* GCC Binärdistributionen */ cut

[[Category:ARM]][[Category:Compiler]]Der [[GCC]] kann auch für [[ARM]] konfiguriert werden. Es gibt diverse fertige Binärdistributionen die für verschiedene Controller mit ARM-Kern verwendet werden können.
== GCC Binärdistributionen ==
* [http://www.mentor.com/embedded-software/codesourcery Mentor Graphics Sourcery Tools (vormals CodeSourcery CodeBench Lite)] Windows, Linux
* [https://launchpad.net/gcc-arm-embedded GCC-ARM-Embedded] für Cortex-R4/R5/M0/M3/M4(F)/M0+. Windows, Linux, Mac, bereitgestellt von ARM selbst, vollständiger Support für FPU's, C++11, kein Code-Size-Limit
* [http://sourceforge.net/projects/devkitpro/ devkitPro]
* [[ARM GCC toolchain for Linux and Mac OS X]]
* [http://www.yagarto.de/ Yagarto] (Windows, mit Eclipse-Integration),
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/#winarm WinARM] (wird derzeit nicht gepflegt)
* [http://gnuarm.com/ GNUARM] (Linux, Windows, wird derzeit nicht gepflegt)

Bei der Auswahl der Toolchain sollte beachtet werden, dass es größere Unterschiede bei den bereitgestellten C-Bibliotheken gibt. Die Sourcery Codebench Lite-Edition stellt z.B. keine Bibliotheken mit FPU-Unterstützung bereit, so dass trotz vorhandener FPU beim Cortex-M4 nur suboptimaler Code erzegt werden kann. Siehe [http://wiki.debian.org/ArmHardFloatPort/VfpComparison] für ein kleines Beispiel und eine Erklärung.

Die im Netz häufig anzutreffende summon-arm Toolchain hat einen der seltenen Compiler-Bugs [http://www.mail-archive.com/gcc-bugs@gcc.gnu.org/msg353473.html] und sollte daher nicht verwendet werden, wenn man floatingpoint-Typen einsetzen möchte. Egal ob mit oder ohne FPU.

Beim Einsatz des gcc in Verbindung mit in C geschriebenem startup-Code bei den Optimierungslevels "-O2" und "-O3" muss zusätzlich "-fno-gcse" gesetzt werden, da ansonsten die von der CPU benötigte NVIC-Tabelle(n) und zugehörige Funktionen u.U. nicht so aussehen wie sie sollten.

Siehe auch [http://embdev.net/topic/129986#1175214 ARM-GCC development resources] im Forum.

== Nutzung mit eigener Umgebung/Kommandozeile ==
Hier einige Hinweise wie man den GCC direkt verwenden kann (zB. mit selbstgebautem makefile), falls man das nicht von einer Entwicklungsumgebung machen lässt.
=== Compiler & Linker Flags ===
Für Eilige, zum Copy&Pasten. Detailinformationen gibt es in der [http://gcc.gnu.org/onlinedocs/gcc/Option-Summary.html#Option-Summary GCC Dokumentation], auch [http://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html#ARM-Options speziell für ARM].
* Mit Optimierungen:
{| class="wikitable"
|-
! Tool/Sprache !! Cortex-M3 !! Cortex-M4F
|-
| C-Compiler (gcc) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -Os -flto || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -Os -flto
|-
| C++ Compiler (g++) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -Os -flto -fno-rtti -fno-exceptions || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -Os -flto -fno-rtti -fno-exceptions
|-
| Assembler (as) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb
|-
| Linken von C Code (mit gcc-Befehl) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -Os -flto -Wl,--gc-sections -static || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -Os -flto -Wl,--gc-sections -static
|-
| Linken von C++ (und C) Code (mit g++-Befehl) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -Os -flto -fno-rtti -fno-exceptions -Wl,--gc-sections -static || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -Os -flto -fno-rtti -fno-exceptions -Wl,--gc-sections -static
|-
|}
* Ohne Optimierungen, mit Debug-Informationen:
{| class="wikitable"
|-
! Tool/Sprache !! Cortex-M3 !! Cortex-M4F
|-
| C-Compiler (gcc) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -g || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -g
|-
| C++ Compiler (g++) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -g -fno-rtti -fno-exceptions || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -g -fno-rtti -fno-exceptions
|-
| Assembler (as) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb
|-
| Linken von C Code (mit gcc-Befehl) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -g -Wl,--gc-sections -static || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -g -Wl,--gc-sections -static
|-
| Linken von C++ (und C) Code (mit g++-Befehl) || -mcpu=cortex-m3 -mfloat-abi=soft -mthumb -ffunction-sections -fdata-sections -g -fno-rtti -fno-exceptions -Wl,--gc-sections -static || -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb -ffunction-sections -fdata-sections -g -fno-rtti -fno-exceptions -Wl,--gc-sections -static
|-
|}

* Siehe auch das [https://launchpadlibrarian.net/135588846/readme.txt Readme vom GCC-ARM-Embedded]
* Um das -flto -Flag verwenden zu können, muss der GCC [http://gcc.gnu.org/onlinedocs/gccint/LTO.html LTO] unterstützen. Beim GCC-ARM-Embedded ist dies ab Version 4.7-2013-q2-update der Fall.
* Die LTO erkennt die ISR's und den Interrupt Vector möglicherweise als "unbenutzt" und optimiert sie daher weg. Dies kann durch Markierung der Funktionen & Variablen mit "__attribute__ ((used))" verhindert werden.
* Alle Compileroptionen müssen auch beim Linken mit angegeben werden (ist in obiger Tabelle berücksichtigt), da auch dann u.U. Code generiert werden kann.
=== Startupcode & Linkerscript ===
* Damit der compilierte Code an den richtigen Stellen im Controller landet (d.h. dem Flash) muss man dem Linker ein Linkerscript mitgeben. Dies geht per "-T ''pfad_zum_linkerscript.ld''" an den Linker-Befehl. Das Script ist praktisch Controller-spezifisch, es gibt Beispiel-Scripte der Controller-Hersteller.
* Damit beim Starten die richtigen Initialisierungen vorgenommen werden (wie globale Variablen und bei C++ Konstruktoren globaler Objekt-Instanzen) muss als erstes ein Startupcode laufen, der dann die main()-Funktion aufruft. Der Startupcode ist meistens in Assembler geschrieben, C/C++-Code ist aber auch möglich. Assemblercode kann per arm-none-eabi-as (Flags s.o.) assemblisiert werden, die resultierende .o -Datei normal mitgelinkt. Auch für den Startupcode gibt es Beispiele der Controller-Hersteller.

Zusammen bieten die beiden Dateien der Anwendung ein Standard-C-Interface, d.h. man kann wie gewohnt globale Variablen verwenden und seinen Code in die main()-Funktion schreiben.
=== FPU der Cortex-M4F nutzen ===
Um die FPU zu nutzen, muss dem Compiler per [[#Compiler_.26_Linker_Flags|Flag]] dazu gebracht werden, FPU-Instruktionen zu generieren.

Außerdem muss vor Benutzung der FPU-Befehle die FPU aktiviert werden, dies geschieht typischerweise im Startupcode, bevor die main() -Funktion aufgerufen wird. Hier die entsprechenden Befehle, falls sie im verwendeten Startupcode nicht onehin schon enthalten sind:
<pre>/*FPU settings*/
ldr r0, =0xE000ED88 /* Enable CP10,CP11 */
ldr r1,[r0]
orr r1,r1,#(0xF << 20)
str r1,[r0]</pre>
In C/C++ unter Verwendung der CMSIS geht es so:
<syntaxhighlight lang="c">
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
</syntaxhighlight>

Weiterhin sollte die GCC-Distribution auch Laufzeitbibliotheken mit FPU-Unterstützung mitbringen (CodeBench lite und Yagarto werden ohne ausgeleifert, GCC-ARM-Embedded mit).

Am Beispiel der STM32F4 mehr dazu in diesem Thread: [http://www.mikrocontroller.net/topic/261021 Floating Pointing Unit STM32F4]
=== Disassemblieren mit GCC ===
arm-none-eabi-objdump -d -t -C pfad_zum_binary.elf

=== Konvertieren zwischen Binary-Formaten beim GCC ===
arm-none-eabi-objcopy -O ''ausgabeformat'' ''eingabe_binary.elf'' ''ausgabe_binary''

Nützlich als Ausgabeformat sind z.B. "ihex" oder "binary".
=== Code-Größe optimieren ===
Obige Flags (insbesondere -flto -Os -ffunction-sections -fdata-sections -Wl,--gc-sections ) verwenden. [http://www.mikrocontroller.net/topic/298976#3197418 Hier] finden sich noch ein par Tips, für den 1. kann aber mittlerweile der GCC-ARM-Embedded direkt verwendet werden, da er jetzt LTO unterstützt (s.o.).

Platinenhersteller

2013-12-02T20:44:10Z

Mthomas: /* Deutschland */

== Einleitung ==
Die Vor- und Nachteile von Platinenherstellern/-lieferanten werden relativ häufig im [http://www.mikrocontroller.net/forum/platinen Forum] diskutiert (und führen ab und zu zu Flamewars :-). Damit man schnell einen Überblick über die verschiedenen Möglichkeiten erhält, soll hier eine Liste zusammengetragen werden.

Jeder kann/soll seinen Beitrag leisten, d.h. wenn man einen Platinenlieferanten kennt, der noch nicht erwähnt ist, einfach hinzufügen. Falls man den Hersteller nicht so gut kennt, einfach mal den Namen und die URL hinzufügen, es gibt sicherlich andere, die den Hersteller so gut kennen, dass sie sich zutrauen, ein Urteil über die Leistung zu fällen.

Eigentümer oder Mitarbeiter der gelisteten Firmen mögen bitte der Versuchung widerstehen, die Einträge mit werbeähnlichen Texten oder Werbung zu ergänzen. Zufriedene Kunden mögen bitte darauf achten, ihre Zufriedenheit so zu formulieren, dass nicht der Eindruck entsteht, der Eintrag sei von einem Hersteller zur "Verschönerung" gemacht worden.

PS.: Das Ganze soll so ähnlich werden wie [[Elektronik-Versender]], da hat das auch sehr gut geklappt!

'''Diese Seite kann nur von angemeldeten Benutzern bearbeitet werden!''' Bei neuen Einträgen bitte die Sortierung beachten.

Einige Hinweise, Hilfestellungen zur Platinenfertigung und Auftragsvergabe gibt es auch in der [http://www.dse-faq.elektronik-kompendium.de/dse-faq.htm#F.6 de.sci.electronics-FAQ].

===Preise===
Zur besseren Vergleichbarkeit bei jedem Hersteller dazu schreiben, was '''eine doppelseitige durchkontaktierte Eurokarte (160mm x 100mm) mit deutscher MwSt.''' ohne Versand kostet.
Dazu noch die Lieferzeit und ob Lötstopplack und Bestückungsdruck dabei ist.
''Zusätzlich'' kann man noch die Preise für andere Formate, Stückzahlen etc. dazu schreiben.

== Liste der Hersteller ==

=== Deutschland ===

==== Accent PCB GmbH ====
Homepage: http://www.accentpcb.com/duitsland-home.html

Eigendarstellung (vgl. auch [http://www.mikrocontroller.net/topic/316646 Forenthread]):
* Leiterplatten "ab 75€ - €99€"
* erfahrene Techniker
* Beratung gratis
* Produktion in Asien und Europa
* auch flexible und "starr-flexible" Platinen

==== Ätzwerk GmbH ====
Homepage: http://www.aetzwerk.de

Eigendarstellung:
* 100x160mm, Lötstopp doppelseitig, Bestückungsdruck einseitig, Stuktur>0,15mm, Bohrungen>0,3mm, 7AT, 59€
* scheint auch an privat zu liefern
* SMD-Schablonen
* Expressfertigung

Erfahrungen:
* verschicken unaufgeforderte Newsletter
* [http://www.mikrocontroller.net/topic/246385 Diskussionsfaden "Ätzwerk GmbH"]

==== am2s ====
Homepage: http://www.am2s.de
* Leiterplatten (Prototypen und Kleinserien, bis hin zur Großserie)
* Eildienst möglich
* Ein- und doppelseitige Leiterplatten, Multilayer.
* Layoutservice
* günstige Preise
* sehr gute Qualität
* Lieferzeit ab 3 AT
* KEINE eigene Leiterplattenfertigung - nur Vertrieb

==== andus electronic ====
Homepage: http://www.andus.de
* Prototypen Fertigung
* Top Qualität
* Top Service
* Vergleichsweise Teuer

==== ANTtronic ====
Homepage: http://www.anttronic.de/pcb/

* gute Preise, aber Lieferzeit beachten!
* 1 Europlatine einseitig kein Lötstoplack 17€ inkl. MwSt +7€ Versand
* 1 Europlatine doppelseitig ''nicht durchkontaktiert'' kein Lötstoplack 23€ inkl. MwSt +7€ Versand; 2Stück 37€

==== Basista Leiterplatten ====
Homepage: http://www.basista.de
* Eurokarte doppelseitig für 52€ inkl. MwSt / mit Stopplack + Best.Druck 94€ inkl. MwSt
* Prototypen standardmäßig chemisch zinnbehandelt
* Preise OK
* Früher geliefert ohne Aufpreis (7 statt 10 AT)
* Qualität OK
* ''Onlinekalkulator''
* 100x160mm, zweiseitig, durchkontaktiert, mit Lötstop, 8AT, 82€

==== Bauer-Elektronik ====
Homepage: http://www.bauer-leiterplatten.de/
* Eurokarte doppelseitig für 61€ inkl. MwSt 8AT Lieferzeit / Stopplack +10% / Best.Druck +10%
* Prototypen aktivzinnbehandelt, dieses lässt sich laut Firmenangaben noch nach Jahren löten
* Eildienst 2h: Versand am selben Tag bei Einsendung bis 13:00 400€ für 2dm²
==== Britze ====
Homepage: http://www.britze.de
* Leiterplatten in kleinen und mittlere Serien
* Musterleiterplatten / Prototypen
* 1- und 2-lagige Leiterplatten
* Multilayer bis 10 Lagen
* Aluminiumträgerleiterplatten
* ''Online-Kalkulator'' für Multinutzen und Leiterplatten
* Beratung/Layout/Entflechtung von Leiterplatten
* 100x160mm, zweiseitig, durchkontaktiert, mit Lötstop, 10AT, 73€
* scheint auch an privat zu liefern

==== B&B Gruppe ====

Homepage: http://www.bb-gruppe.de

Hersteller aus Mittweida/Sachsen 
Klein- und Musterserien, Spezialist Sondertechniken 
Zusätzliche Partner für Großserien in Asien mit eigenen Mitarbeitern

* Ein- und Doppelseitige Leiterplatten
* Multilayer
* Schleifringe
* Starrflex
* Hochstromleiterplatte
* Dickkupfer
* Flexlam
* Dünnstleiterplatte
* IMS
* HDI Leiterplatte
* E-Test inklusive
* Datenformate: Gerber, Eagle, Excellon, Sieb & Meier
* Eildienst möglich
* Abrufeinteilung und Konsignationslager möglich

B&B Sachsenelektronik GmbH 
Leipziger Straße 40 
09648 Mittweida 

Tel: 03727/62 97 0 
Fax: 03727/ 62 97 24 
Email: info@bb-gruppe.de 

==== Contag====

Homepage: http://www.contag.de
* SAUSCHNELL- ab 4 STUNDEN(!)
* Aber auch sehr teuer
* Qualität sehr gut

==== Christian Enzmann Gmbh ====

Hompage: http://www.enzmann.de/ 
E-Mail: info@enzmann.de 
 
'''Angebot:''' 
 
''Prototypen'' 
- Schnelle Reaktion auf individuelle Kundenwünsche 
- Liefertermine werden eingehalten 
 
''Serienfertigung'' 
- gefertigten Prototypen sollen später in Produktion von Großserien gehen 
- Kunden können mit großen Stückzahlen versorgt werden 

==== Deutschlaender Electronic GmbH ====

Homepage: http://www.deutschlaender.net 
E-Mail: vertrieb@deutschlaender.net 

Ausführung: 
• Leiterbahnbreite und -abstand ab 100 µm 
• Bohrdurchmesser (Endmaß) ab 0,2 mm 
• Sacklöcher 
• Halblöcher 
• Tiefenfräsung 

Materialien: 
• Materialstärke ab 0,5 mm bis 2,4mm 
• Kupferauflagen: 35 µm, 70 µm, 105 µm,145 µm und 235 µm 
• Hoch-Tg oder Aluminiummaterial 

Servicedrucke: 
• Fotosensitiver Lötstoplack (grün,schwarz,rot und weiß) 
• Bestückungsdruck (weiß,gelb,schwarz und rot) 
• Carbondruck (Kontaktflächen) 
• Abziehlack 
• Viadruck 

Mechanische Bearbeitung: 
CNC-Fräsen für: 
• Kontur 
• Schlitze - auch durchkontaktiert 
• Kerb Ritzen für Kontur, Sollbruchstellen, Sprungritzen 
• Kontur anfasen, z.B. für Steckerkamm 

Oberflächenveredelung: 
• HAL bleifrei / PbSn 
• Chemisch Nickel/Gold(Ni/Au) 
• Chemisch Zinn (Sn) 
• Galvanisch Nickel/Gold (Ni/Au, Hartgold) 

* Datenformate: Gerber, Eagle, Target, Autocad, Excellon, Sieb & Meier 
* Eildienst möglich (3AT/5AT/7AT) 

==== EPN Electroprint GmbH ====

Homepage: http://www.epn.de
* Hersteller aus Neustadt an der Orla/Thüringen
* 8 Tage Lieferzeit, Eilservice 24h auch möglich
* Single-Layer, Multi-Layer (bis 22 Lagen als Spezialanfertigung!), Dickkupfer
* Verzinnung: Hot-Air-Leveling oder chemisch Zinn
* Lötstopplack verschiedene Farben nach Absprache möglich
* Stencil-Fertigung
* Thüringer Staatspreis für Qualität

==== Elischer Leiterplatten ====
e-mail: aurel-elischer@t-online.de
* Firmensitz / Post-Adresse: Dipl.-Ing. Aurel Elischer, Leiterplatten, Am Forst 7, 72574 Bad Urach, Tel. 07125/4498, Ust.Id.-Nr.: DE 223 09 4959
* Layoutentwurf, LP Entwicklung, herstellen, bestücken, löten, prüfen
* 3 KW Lieferzeit (nach Vereinbarung auch kürzer)
* sehr gute Preise, Qual.1A
* einen Preis zu nennen, wäre Unfair. Es ist abhängig davon ob:
** 1 oder 2-seitig
** Leiterbahnenabstand und Lötflächenanstände kleiner oder größer als 0,3 mm
** Cu 30, 70, 110 µm
** Stärke der LP 1,0; 1,6; 2,0; ... mm
** mit (1- oder 2-seitig, grün, blau, weiß, schwarz,...)oder ohne Beschriftung
** mit oder ohne Stoplack
** gefräst oder nur geritzt
** einzeln oder X-Fach-Montage
* BITTE BEACHTEN: unter 10 St lohnt es sich für Sie nicht: für die erste Lieferung müssen wir einmalig ca 65€ berechnen (Film, Maske, Bohrdatei, ...)
* ab 10 St unbedingt Gerber 274X und Exellon für das Angebot (Angebot kostenlos) beifügen; keine Angst: Gerber 274X und Exellon kann man aus jedem Programm generieren

==== Elk Tronic ====

Homepage [http://www.elk-tronic.de/ http://www.elk-tronic.de]
*Entwicklung und Fertigung von Kleingeräten und Kleinserien
*Verkauf von IC-Adaptern und Bauteilen

==== Fischer Leiterplatten GmbH ====
Homepage: http://www.fischer-leiterplatten.de
* 1 Europlatine inkl. Lack, E-Test, ohne Bestückungsdruck für 46,41€ inkl. MwSt in 10 Tagen + Versand
* 1 Europlatine inkl. Lack, E-Test, Best.-Druck top oder bottom für 58,31€ inkl. MwSt in 10 Tagen + Versand
* 1 Europlatine inkl. Lack, E-Test, Best.-Druck doppelseitig für 117,81€ inkl. MwSt in 10 Tagen + Versand
* max. 4 lagig
* Bestückungsdruck doppelseitig
* Bohrungen no limit
* min Clearance 0,15mm (Standard)
* min Bohrdurchmesser 0,3mm (Standard)
* Gerber/Eagle/Protel/Target
* mehrere Leiterplatten können auf einer Europakarte, zum Preis einer Europakarte, zusammengefasst werden und werden automatisch vereinzelt.
* Überlieferung wird kostenlos beigelegt. (Sprich: in der Regel werden mehr Leiterplatten geliefert als bestellt.)
* Verkauf nur an Gewerbetreibende (aber es wird kein Gewerbenachweis verlangt ;) )
* Erfahrungen: [http://www.mikrocontroller.net/topic/209947#2078731]

==== GLS Leiterplatten-Service GmbH ====
Homepage: http://www.leiterplattenprototypen.de
* Prototypenfertigung bei Chemnitz
* Top Qualität (mittleres Preisniveau)
* Top Service
* Prüfung der Layoutdaten in der CAM
* Standardlieferzeit: 10 Arbeitstage
* Eilservice bis 3 Arbeitstage (mit Aufpreis)
* Oberfläche Standard: HAL bleifrei; aber auch z. B. chem. Gold, chem. Zinn und HAL bleihaltig
* einseitige, nichtdurchkontaktierte Leiterplatten
* durchkontaktierte Leiterplatten
* Multilayer: bis 8-Lagen
* bietet zusätzlichen Service rund um die Leiterplatte: Erstellung von Leiterplattenlayouts und Digitalisierung/Scannen von alten Fertigungsfilmen, Papierausdrucken oder vorhandenen Musterleiterplatten
* SMD Schablonen

==== HAKA Elektronik-Leiterplatten GmbH ====
Homepage: http://www.haka-lp.de/
* Zwillingsangebot: 2 identische Europakarten für 50€ (durchkontaktiert, Lötstop, kein Bestückungsdruck, nur Eagle- oder Target-Dateien), auch hierbei kostenlose Duplizierung kleinerer Layouts
* Zwillingsangebot: 2 identische Doppel-Eurokarten (200x160) für 90€, gleiche Bedingungen wie oben
* Prototypenangebot (min. Abstand 0,15 mm, min. Leiterbahnbreite 0,15 mm, kleinste Bohrung 0,3 mm, durchkontaktiert, Lötstop), 160x100mm in 2AT = 260EUR .. 8AT = 72 EUR .. 15AT = 63 EUR
* bei Platinen kleiner 1 qdm gibt es entsprechend mehr ohne Aufpreis
* Lieferzeit ab 3 Werktage; Achtung: Lieferzeit sind nur Circa-Werte und nicht verbindlich. Auch bei Aufpreis (AGB)!
* sehr gute Qualität



==== IBR Leiterplatten GmbH & Co. KG ====
Homepage: http://www.ringler.de
* sehr freundlicher und kompetenter Service
* reagiert sehr schnell
* Qualität TOP
* Preise TOP - günstige Einmalkosten/Setup
* kann auch Dinge wie Alu, Starrflex, fine pitch oder 0,1 er vias
* Lieferzeit ab 2 Tage
* 2 Lagen in 10 Tagen - 10 Lagen Multilayer ohne besondere Nachfrage binnen 18 Tagen geliefert
* liefert generell schneller als bestätigt / macht auch Rahmenaufträge
* Mehrmengen bei Prototypen werden kostenlos geliefert
* SMD-Schablonen

==== ILFA Feinstleitertechnik GmbH ====
Homepage: http://www.ilfa.de

==== Eurocircuits GmbH

Hompage: http://www.eurocircuits.de

* ideal für kleine Stückzahlen ab 1 Stück
* Lieferzeit ab 2 AT
* gute Preise bei Prototypen aber auch bei mittleren Stückzahlen
* Online Datenvisualisierung und DRC Check
* SMD - Schablonen
* Preisberechnung eindeutig ohne versteckte Kosten

==== Julian Hüsing CNC Leiterplattenprototypen (Privat) ====
* Europlatine 100x160 1 bis 2 Seitig ca. 20-40€ (Berechnung Maschinenzeit)
* Isolationsbreiten abhängig vom Stichel: minimale Isolationsbreite ca. 0,15 mm
* Bohr und Fräsarbeiten, auch aufwändige Konturen realisierbar
* Lieferzeit 8AT, ansonsten Aufpreis bei schnellerer Lieferung
mailto:julian.huesing85@googlemail.com

==== kessler systems GmbH ====
Homepage: http://www.kesslersystems.de
* Leiterplatten und Bestückung (Prototypen und Kleinserien, bis hin zur Großserie)
* Sehr schnell
* Ein- und doppelseitige Leiterplatten, Multilayer.
* Layoutservice
* SMD- und THT Bestückung
* Gerätebau
* günstige Preise
* sehr gute Qualität
* Lieferzeit an 3 AT
* Bauelementebeschaffung auch schon bei 1 Stück (super funktioniert)

==== LEITON ====
Homepage: [http://www.leiton.de/ leiterplatten-online.de]
* Flexible Leiterplatten online kalkulieren
* Alle Layouts werden in der CAM eingehend geprüft
* Schnellste Bearbeitung von Anfragen
* Diverse Spezialfertigungen (Aluminiumkern, HF, hoch-Tg etc.)
* Fließender Übergang vom Prototyp in die Serie möglich
* Niederlassungen in Hongkong & China für Großserien (LeitOn HK Ltd.)
* Relativ günstig
* bei mehreren kleinen Leiterplatten wird nach Gesamtfläche berechnet, nicht nach Mindestfläche x Mindestpreis x Stückzahl
* Doppelseitige Europlatine mit Lötstop in 8 Tagen 61,25 Eur
* In 15 Tagen 49 Eur
* Gute Qualität
* Bis 8-lagig und ab 12 Std.

==== Leiterplatten-Express-Service GmbH ====
Homepage: http://www.les-gmbh.com

==== Microcirtec ====
Homepage: http://www.microcirtec.de
* Direct - Online - Shop — zum Kalkulieren-Bestellen und Kaufen
* Mit Auftragsverfolgung per Online
* Vom Rapid Prototyping bis zur Rapid Mass-Production
* Qualität betrachten wir als selbstverständlich
* Allerdings ist die Anmelde-Prozedur ein Drama
* Preiswert

==== MME-Leiterplatten ====
Homepage: http://mme-pcb.de

* [http://www.mikrocontroller.net/topic/73790 Thread 'MME-PCB, Erfahrungen'](bereits 4 Jahre alt)
* Verkauft über seine Homepage (Onlinekalkulator)
* Europakarte: ES: 20,60 EUR, DSDK: 41,50 EUR
* Durchkontaktierung bei zweiseitigen Leiterplatten ist im Preis inbegriffen
* Trennen und Bohren inklusive
* Stopplack inklusive
* Bestückungsdruck (16€) kosten extra
* min. Abstand 0,20 mm, min. Leiterbahnbreite 0,20 mm, kleinste Bohrung 0,4 mm

* Lieferzeit 8-12 Arbeitstage (bei mir waren es nur 5 Werktage)
* Überlieferung kostet nichts (häufig wird eine Leiterplatte mehr geliefert, bei mir waren es bei vier bestellten Platinen zwei mehr)
* Mit einer bestellten einseitigen Platine (DIL Bauteile) bin ich sehr zufrieden
* Die auf der Seite beworbene Lierferzeit wird meist eingehalten.
* Bis zu zehn unterschiedliche Karten können in einem Auftrag gepoolt werden -> preiswerter weil dm² kosten über alle gerechnet werden.
* Antwortet bei mir nicht auf emails, telefonisch kaum zu erreichen.
*Kommunikation hat sich erheblich verbesssert.
* Kommunikation wieder schleppend ( stand: August 2013 )

==== Multi Printed Circuit Boards Ltd. ====
Homepage: http://www.multi-circuit-boards.eu
* nur für Gewerbetreibende
* Eurokarte doppelseitig mit Lötstopplack, Bestückungsdruck und E-Test in 6AT: 68,54€ inkl. MwSt
* Online Kalkulator

* farbiger Lötstopplack und Bestückungsdruck möglich
* 48 Stunden Express
* Kompletter Design-Rule-Check der CAM-Daten
* Diverse Spezialfertigungen (Flex, Starrflex, Metallkern, HF, hoch-Tg, etc.)
* Sehr gute Qualität
* Liefertermine werden gerne etwas überschritten( auch bei Eilservice)

==== M & V Leiterplatten - Vertriebs GmbH ====
Homepage:  http://pcb-center.de/
* Bin sehr zufrieden, gute Preise, 10 - 14 Tage
* Top Qualität, nichts auszusetzen
* Qualität sehr gut, hohe Auflösung, auch SMD fine pitch möglich
* Eurokarte doppelseitig 2xStopplack FR4 bleifrei konturgefräst 63€ inkl. MwSt zzgl. Versand
* Eurokarte einseitig 1xStopplack FR4 bleifrei konturgefräst 44€ inkl. MwSt zzgl. Versand

* Freundlicher Kontakt, Leiterplatten sehen gut aus, lieferten 6 Tage zu frueh!
* Biszu fünf unterschiedliche Karten können in einem Auftrag gepoolt werden -> preiswerter weil dm² kosten über alle gerechnet werden.

==== PCB Joker ====
Homepage: http://www.pcb-joker.com/
* Poolkonzept extrem!
* 1- bis 4 Lagen Multilayer
* Allgemein schnell und geringe Terminzuschläge
* Leiterplatten werden bei verschiedenen deutschen Herstellern platziert
* Sehr günstig , sehr übersichtliche Onlinekalkulation
* Bezahlung per PayPal oder Vorkasse
* Farbe, Dicke, Kupferauflage und Oberfläche können nicht festgelegt werden, sondern sind "Joker"

==== PCB Pool ====
Homepage: http://www.pcb-pool.de/
Alternativname: BETA Layout
* Standort: Im Aartal 14, 65326 Aarbergen, [http://www.openstreetmap.de/karte.html?zoom=17&lat=50.23705&lon=8.06361&layers=B000TT Link zur Openstreetmap Karte]
* ideal für einzelne Boards und Klein(st)serien
* Preise im üblichen Rahmen
* Günstigere Preise für 10er oder 20er Auflage
* sehr gute Qualität
* Lieferzeit ab 2 AT
* SMD-Schablonen
* Aktzeptieren von den gängigsten Layoutprogrammen die Boarddaten direkt. AUCH von KiCAD. Siehe http://www.pcb-pool.com/ppde/info_dataformat.html

==== Precoplat ====

Homepage: http://www.precoplat.de/

* Standort: Krefeld, Oberdiessemer Str. 15, 47805 Krefeld, [http://www.openstreetmap.de/karte.html?zoom=17&lat=51.32818&lon=6.58062&layers=B000TT Link zur Openstreetmap Karte]
* Prototypen, Großserien und alles dazwischen.
* Extrem flexibel im Angebot (Fläche/Lieferzeit, Blitz-Prototyping, Rapid-Mass-Produktion)
* Online Bestellung
* sehr gute Qualität
* bis 24 Lagen
* Mikro-Vias 100-200u
* Carbonlack
* Elektrischer Test (Flying probe + Nadelbett)

==== Q-print/Q-PCB ====
Homepage: http://www.Q-PCB.de
* ideal für einzelne Boards und Klein(st)serien
* supergünstige Preise
* gute Qualität (u.U. Lötstop etwas unsauber)
* keine Zusatzpreise für 2x Lötstoplack o.ä.
* 150 µm kleinste Strukturbreite
* ohne Aufpreis bekommt man entweder HAL oder Ni/Au, gegen Aufpreis kann man aus einem von beiden wählen
* SMD-Schablonen
* Lieferzeit ab 4 AT
* Platine 50mm x 60mm, doppelseitig: ~45€ incl. Versand und ~5€ Nachnahme
* Platine 85mm x 58mm, doppelseitig: 33€ zzgl 6,80 Versand
* Platine 100mm x 160mm, doppelseitig: 49€ +7€ für Lötstopp +6,80€ Versand

==== Ruwel ====

Homepage: http://www.ruwel.com/

* Standort: Am Holländer See 70, 47608 Geldern, [http://www.openstreetmap.de/karte.html?zoom=17&lat=51.50451&lon=6.32046&layers=B000TT Link zur Openstreetmap Karte]
* Werke in Deutschland und China
* Überwiegend Großserien.
* Hochtemperatur, Dickkupfer, Kupferinlays, Semiflex, Sacklochbohren.

==== SMTstencil (Großbritannien) ====
SMD-Schablonen aus Polyester gelasert, preiswert, kleinste Strukturen 0,25 x 0,25 mm², kleinster Abstand 0,3 mm

Homepage: http://smtstencil.co.uk/

==== Steimer Leiterplatten GmbH ====
Homepage: http://www.steimer.de

==== The PCB-Shop / Europrint Deutschland GmbH ====
Homepage: http://www.thepcbshop.com
* Punktabzug, da der Preisrechner nur mit Internet Explorer funktioniert
* gute Qualität
* guter Preis (inkl. gratis Überlieferungen - 30 kleine Platinen bestellt, 35 bekommen)
* wenig Statusinformationen (Link zur Statusseite kommt per Mail, dort ändert sich der Status und der Empfänger eigentlich täglich - ist aber trotzdem fristgerecht angekommen)

==== Würth Elektronik GmbH & Co. KG ====
Homepage: http://www.we-online.de
* gehört sicherlich nicht zu den preisgünstigsten
* kann Bauteile in der Leiterplatte fertigen (R, C, Potis u.a.)
* beherrscht Microvias in allen erdenklichen Varianten
* sehr kompetentes Ansprechpersonal

==== Onlineshop WEdirekt ====

Homepage: http://www.wedirekt.de
* PCB's in Basistechnologie, 2-8 Lagen
* SMD Schablonen in allen Ausführungen
* Europlatine doppelseitig mit Lötstopplack 67€ inkl. MwSt
* Design- und Applikationsfachbücher rund um EMV


=== Deutschland sehr günstige===
Diese Hersteller zeichnen sich durch einen sehr günstigen Preis von '''unter 30€ pro doppelseitiger Eurokarte''' aus und können (bis auf pcb-devboards) '''keine Durchkontaktierungen''' herstellen.

==== EBC Utz Kohl ====
Homepage: [http://www.e-b-c-elektronik.de http://www.e-b-c-elektronik.de]
* recht einfach gehalten, daher wirklich günstig
* Ideal für den Bastler, denen es auf den Preis ankommt
* Geätzt einseitig Euroformat 160 x 100mm 16,- EUR (zzgl 1,- EUR Entsorgungspauschale pro Platine)
* Geätzt doppelseitig Euroformat 160 x 100mm 26,20 (zzgl 2,- EUR Entsorgungspauschale pro Platine)
* Geometrie: Leiterbahnabstand/-breite >0.3/0.3mm; Bohrdurchmesser >0.8mm?; Bohrrestring >? = D-d; Leiterplattengröße <160x100mm?; ein- und doppelseitig
* doppelseitige Platinen sind nicht durchkontaktiert !
* eigentlich ein Ladengeschäft, versendet jedoch auch

==== Platinenbelichter ====

Homepage: http://www.platinenbelichter.de
* eine doppelseitige Europlatine kostet 14,90 EUR Grundpreis + 2,6 Cent je Bohrung
* Geometrie: Leiterbahnabstand/-breite >0.18/0.18mm; Bohrdurchmesser >0.4mm; Bohrrestring >0.25mm = D-d; Leiterplattengröße <300x200mm; ein- und doppelseitig
* Lötstopplack grün auf anfrage möglich
* Express Service möglich
* Scannservice
* Layoutherstellung vom Schaltplan bis zur fertigen Platine
* Macht auch Bestückungsarbeiten in Top Qualität
* Qualität ist mehr als ausreichend für TQFP
* gute Lötbarkeit der Platinen

Nachteile
* Keine Durchkontaktierungen möglich
* Zum Teil lange Lieferzeit (Bis zu 2 Monate)
* Bei Nachfrage spärliche oder gar keine Antwort

==== Platinendesign ====
Homepage: http://www.platinendesign.de/
* Geometrie: Leiterbahnabstand/-breite > 0.25/0.25mm; Bohrdurchmesser >?; Bohrrestring > 0.3mm = D-d; Leiterplattengröße < 300×200mm; ein- und doppelseitig
* eine doppelseitige Europlatine kostet 14 EUR Grundpreis + Bohrung 2cent + Optionen
* keine Durchkontaktierungen möglich
* Lötstopplack grün
* Lieferzeit von bis zu 8 Arbeitstagen nach Geldeingang
* Zeitweise geschlossen, Neueröffnung am 31.3.2013

==== Ertürk Electronic ====
Website: http://www.erturk.de

e-mail: [mailto:info@erturk.de info@erturk.de]
* Wir rechnen nach dm², in unserem Homepage können Sie selber sehen was Ihre Platine kostet (zur Zeit noch in Aufbau)
* Platine 1seitig FR4, 8€/dm²
* Chemische Verzinnung optional erhältlich
* Geometrie: Leiterbahnabstand/-breite > 0.2/0.2mm; Bohrdurchmesser > 0.4mm; Bohrrestring >0.3mm, Leiterplattengröße < 200×300mm; ein- und doppelseitig
* Sehr hohe Qualität
* Bohrung möglich (ab 10 dm² CNC gesteuert), 0,03 Euro pro Bohrung
* Lieferzeit meistens nach Geldeingang oder bis 3 Arbeitstage
* Ab 15 Platinen sind Durchkontaktierungen, Lötstoplack, Bohrungen und Positionsdruck möglich (Lieferzeit bis zu 2 Wochen). Anfrage und Auftragsannahme nur mit Gerberdaten oder Eagle Daten möglich.
* Für ein Prototyp-Angebot reicht eine Eagle, Sprintlayout- Target3001 oder PDF-Datei schon aus. PDF muss im Maßstab 1:1 und schwarz/weiß sein
* Verpackung und Versand von 2,50 bis 5,90 Euro innerhalb Deutschland egal wieviel Sie bestellen
* Mindestauftragsannahme ab 10,50,-- Euro Inklusiver Verpackung/Versand.
* Stand: Juli 2013

==== Cadgrafik Bauriedl (nur Filme) ====
Homepage: [http://cadgrafik-bauriedl.de/leiterplattenfilme.htm]
* Überträgt Layouts auf hochwertige Folie/Film zum Selberätzen
* 1,15 € / 100 cm² Film, 2,50 € Mindestbestellwert (Stand März 2009)
* 2 € Porto (Stand März 2009)

==== pcb-devboards.de (Leiterplatten, HF- und Mikrowellen-Prototypen inkl. Durchkontaktierung)====

++++++ FR4-Standard 0,5-3,20mm, 35/70µmCu, Farbe(FR4): Standard, Schwarz ++++++

Homepage: http://www.pcb-devboards.de/catalog/index.php?cPath=38_55_157

* Einseitige und doppelseitige durchkontaktierte Leiterplatten
* Oberfläche: chemisch Zinn
* Basismaterial FR4 Farbe: Standard, Schwarz.
* Kupfer-Endstärke; 35µmCU und 70µmCU.
* Fertigung im Nutzen, folgende Rohling-Größen verfügbar:

FR4 1.60mm:
* 45x90mm (0,41dm²) - doppelseitig DK = 8,99 €.
* 100x80mm (0.80dm²) - doppelseitig DK = 13,99 €.
* 95x90mm (0,85dm²) - doppelseitig DK = 13,99 €.
* 160x100mm (1,60dm²) - doppelseitig DK = 23,49 €.
* 195x90mm (1,75dm²) - doppelseitig DK = 23,49 €.
* 195x140mm (2,7dm²) - doppelseitig DK = 29,99 €.
* 290x90mm (2,7dm²) - doppelseitig DK = 29,99 €.
* 290x195mm (5,65dm²) - doppelseitig DK = 49,99 €.

* 45x90mm (0,41dm²) - einseitig = 5,99 €.
* 100x80mm (0.80dm²) - einseitig = 9,99 €.
* 95x90mm (0,85dm²) - einseitig = 9,99 €.
* 160x100mm (1,60dm²) - einseitig = 16,49 €.
* 200x90mm (1,80dm²) - einseitig = 16,49 €.
* 290x95mm (2,75dm²) - einseitig = 22,99 €.
* 200x140mm (2,80dm²) - einseitig = 22,99 €.
* 290x200mm (5,80dm²) - einseitig = 39,99 €.

FR4 0.5mm/0.8mm/1.0mm:
* 290x195mm (5,65dm²) - doppelseitig DK = 49,99 €.

FR4 2.0mm:
* 290x195mm (5,65dm²) - doppelseitig DK = 54,99 €.

FR4 3.2mm:
* 290x195mm (5,65dm²) - doppelseitig DK = 59,99 €.

Fertigungsvorgaben, Standard Leiterplatten::
* Geometrie: Leiterbahnabstand/-breite =>0.2/0.2mm;
* Kleinster Restring umlaufend: 0.20mm = (PAD - Bohrung)/2;
* max. Leiterplattengröße <290x195mm (5,65dm²);
* Unlimitierte Bohrungen ab 0,3mm (von der LP-Dicke abhängig) bis 6,3mm, ab 6,3mm werden die Bohrungen gefräst.
* LP-Dicke (0,50mm - 1,60mm): ab 0,3mm bis 6,3mm
* LP-Dicke 2,00mm: ab 0,4mm bis 6,3mm
* LP-Dicke 3,20mm: ab 0,5mm bis 6,3mm
* Optional Lötstoppmaske (70µm Laminat in grün) und ohne Bestückungsdruck

++++++ ENDE FR4-Standard ++++++

++++++ HF-Leiterplatten, Basismaterial RO4003C, 0,51mm/0,81mm/1.52mm, 35µmCU ++++++

Homepage: http://www.pcb-devboards.de/catalog/index.php?cPath=38_55_181_165

* Doppelseitige durchkontaktierte HF-Leiterplatten
* Oberfläche: chemisch Silber/Zinn
* Basismaterial RO4003C, Farbe: Weiß
* Kupfer-Endstärke; 35µmCU
* Fertigung im Nutzen, folgende Rohling-Größen verfügbar:

RO4003C 0.51mm:
* 195x90mm (1,75dm²) - doppelseitig DK = 39,99 €.
* 195x140mm (2,7dm²) - doppelseitig DK = 51,99 €.
* 290x195mm (5,65dm²) - doppelseitig DK = 87,49 €.

RO4003C 0.81mm:
* 195x90mm (1,75dm²) - doppelseitig DK = 39,99 €.
* 195x140mm (2,7dm²) - doppelseitig DK = 51,99 €.
* 290x195mm (5,65dm²) - doppelseitig DK = 87,49 €.

RO4003C 1.52mm:
* 195x90mm (1,75dm²) - doppelseitig DK = 53,49 €.
* 195x140mm (2,7dm²) - doppelseitig DK = 69,00 €.
* 290x195mm (5,65dm²) - doppelseitig DK = 117,49 €.

Fertigungsvorgaben, HF-Leiterplatten::
* Geometrie: Leiterbahnabstand/-breite =>150/150µm;
* Kleinster Restring umlaufend: 150µm = (PAD - Bohrung)/2;
* max. Leiterplattengröße <290x195mm (5,65dm²);
* Unlimitierte Bohrungen ab 0,3mm bis 6,3mm, ab 6,3mm werden die Bohrungen gefräst.
* ohne Lötstoppmaske und Bestückungsdruck

++++++ ENDE HF-Leiterplatten ++++++

Allgemeine Informationen::
* Beliebige Stückzahlen von Einzelplatinen, auch im Nutzen, der Abstand von Platinen muss mindesten 4mm betragen
* Lieferzeit, Fertigung alle 10-15 Arbeitstage, die Fertigungstermine werden auf der Webseite angegeben.
* Anfrage und Auftragsannahme mit Eagle, Target (freeware), Design Spark oder extended Gerberdaten möglich.
* Verpackung und Versand ab 4,75 Euro (für Stammkunden ab 2,75EUR) innerhalb Deutschland

++++++ ENDE ++++++

=== Ausland ===

==== BatchPCB ====
Homepage: http://www.batchpcb.com (USA)
* Vermittler und keine eigene Herstellung ("PCB pooling service"), Hersteller vermutlich meist [[Platinenhersteller#Gold Phoenix|Gold Phoenix]]
* verbandelt mit Sparkfun ("off shoot of Spark Fun Electronics")
* "We only offer one service at this time: 2 layer PCBs with soldermask both sides and silkscreen both sides. The minimum trace width is 8mil with 8 mil spacing."
* relativ günstig, lange Lieferzeiten, weiteres siehe Homepage und [http://batchpcb.com/index.php/Faq BatchPCB FAQ]

==== BILEX-LP ====
Homepage http://www.bilex-lp.com/ (Bulgarien)
* deutschsprechender Ansprechpartner
* liefern bleifreie Platinen(RoHs konform)
* 31€ für eine doppelseitige Eurokarte ohne Lack und Druck
* SMD- und THT Bestückung
* Layoutservice
* Lieferzeit ab 3-4 AT
* insgesamt von 5 bis 7 AT Anlieferung bei Airmail (Porto ab 4,-Euro)
* FedEx wollte von Bulgarien aus ab 27,-Euro, 1-2AT)
* Löcher größer 6 mm wurden nicht gebohrt, sondern gefräst(gegen Anfrage)
* Berichtete Qualitätsmängel (in Einzelfällen): ausgefranste Platinenfräsung, Lötstoplack hebt ab(nur bei Sn-Pb beschichtung, nicht bei Ni-Au).
* Fräsungen müssen extra bestellt werden! Aber trotzdem günstig

==== CUBE CZ s.r.o. ====
Homepage http://www.cube.cz/ (Tschechische Republik)

* kein Termineinhaltung bei Eilservice - Lieferung hat sich durch wiederholte DRC Checks (dauern jeweils einen Tag) und Vorauskassa statt Zahlungsziel 20 Tage wie auf der Rechnung angegeben von 4AT auf 10AT verzögert
* Keine Design Rules auf der Homepage verfügbar
* UL Zertifikat aus 2001 für nur 6 Mil Traces
* für Deutsche Verhältnisse günstig

==== dfrobot ====
Homepage http://www.dfrobot.com/ (China)

* Mindestens 10Stk
* Größe in 5cm Preisrasterung
* 10Stk 5x5 cm 9.9USD => 1USD/Stk
* 200Stk 5x5 cm 69.5USD => 0.35USD/Stk
* 4 Lagig 10Stk 5x5 cm 64.90USD => 6.49USD/Stk

==== Euro PCB Ltd. ====
Homepage http://www.europcb.com/ (Großbritannien)
* Günstige Leiterplatten
* Schnelle Lieferung
* Qualitativ OK

12.02.2012: Webseite ist leer; Firma terminiert?

==== Gold Phoenix ====
Homepage http://www.goldphoenixpcb.biz/ (VR China)

==== ITead Studio PCB prototyping service ====
Homepage http://iteadstudio.com/store/index.php?main_page=index&cPath=19_20 (VR China)
* Sehr günstige Leiterplatten
* Relativ günstige Lieferung
* 10 Stück mit jeweils 5x5cm für 9,90€
* Qulität relativ gut
* 100% E-Test
* Teilweise Probleme mit Gerberdateien, die knapp am Limit (6 mil) sind
* Testvideo: [http://www.eevblog.com/2011/03/11/eevblog-155-itead-studio-pcb-prototype-goof/ EEVBlog #155]

==== LNAFIN ====
Homepage: http://electronics-pcb.com (Finland)
Produkte: http://electronics-pcb.com/shop (Finland)
Email : pcb@lnafin.com

* PCB Vertrieb mit Mikrowellenbereich und Multilagig HDI Kompetenz
* Leiterplatten fuer Industrie und auch als Kleinserien (kein MOQ)
* Elektronik und Layout Design Hilfe (bitte siehe Produkte)
* Auch ASIC design und PCBA (14 ASIC Erfahrung)
* Sicher Service auf Deutsch.

==== MakePCB ====
Homepage http://www.makepcb.com/ (Shanghai, VR China)
* Ich habe bei MakePCB Platinen geordert und als Zahlungsart Paypal angegeben. Die automatische Bestaetigung kam, es stand nochmal explizit drin dass ich Paypal als Zahlungsart gewaehlt habe und die Bemerkung, dass bei Zahlungsart Paypal in 2 Tagen eine Mail an die gleiche Adresse kaeme mit den Daten für Paypal. Naja, nach 4 Tagen war immernoch nichts da, ich habe denen eine Mail geschrieben und nochmal nach den "versprochenen" Paypaldaten gefragt. Drei Tage spaeter war immernoch nichts da, also habe ich die Bestellung abgebrochen. Am 8. Tag kam die Zahlungsforderung über Paypal, kein Wort der Erklaerung. Am 10. Tag kamen zwei identische Mails, die sagten man haette die PayPal-Zahlungsaufforderung schon geschickt. Irgendwas laeuft in dem Laden also schief.
* Weiterer Erfahrungsbericht zu MakePCB: Nach einiger Überlegung habe ich mich entschieden, es zu wagen, bei MakePCB Platinen zu bestellen. Meine Platine hatte halbes Euro-Format, aus Kostengründen habe ich gleich 5 Stück bestellt. Der gesamte Preis betrug ca. 45 €, Zahlung per PayPal funktionierte ohne Probleme. Auf der Internetseite von MakePCB wurde für die Produktion 14 Tage, für Shipment 10-14 Tage veranschlagt. Nach der Bestellung konnte ich den Status der Bestellung online in einer Tabelle einsehen. Nach etwas mehr als den veranschlagten 4 Wochen kamen heute die Platinen am. Die Verpackung wirkte nicht sehr professionell (gepolsterter Umschlag, auf den mit Filzstift meine Anschrift geschrieben war), nach dem Aufreissen des Umschlags hielt ich ein mehrfach mit gepolsterter Folie und Klebeband umklebtes Päckchen in der Hand. Erst als ich die Folie entfernt hatte kam eine professionell mit Luftpolsterfolie verschweisste Packung zum Vorschein. Die Platinen sehen, so weit ich bisher beurteilen kann, gut aus, lediglich der Bestückungsdruck ist ein wenig versetzt. Ein kurzer exemplarischer Test mit dem Multimeter sah auch in Ordnung aus. Alles in allem macht das Angebot, insbesondere zu dem Preis, einen echt guten Eindruck. Ich kann es nur empfehlen.

==== OLIMEX Ltd. ====
Homepage http://www.olimex.com (Bulgarien)

Habe mehrere Jahre bei Olimex meine Prototypen herstellen lassen. Stets saubere Arbeit erhalten. Bis ich denen mal falsche Gerber-Dateien zusandte. Als ich einige Stunden spaeter den Fehler bemerkt hatte, bat ich um Stornierung und Neuzusendung. Gegen ein zusaetzliches Entgelt wurde dies akzeptiert.
Die angesagten Zusatzkosten wurden zwar von mir nicht abgebucht, aber ich erhielt 1 Woche spaeter die anfaenglich falsch zugesandten PCB's.
Die Zusammenfassung des darauffolgenden Email-Verkehrs: Ein Schulterzucken seitens Olimex und die Bitte, eine neue, kostenpflichte Bestellung zu taetigen.

==== PAD2PAD ====
Homepage http://www.pad2pad.com/ (USA)
* Bestücken die Platinen auch mit Digikey-Bauteilen.

==== PCBCart ====
Homepage http://www.pcbcart.com/ (China)
* auch kompliziertere Designs
* schnell und zuverlässig
* Eurokarte doppelseitig mit Lötstopp beidseitig und Bestückungsdruck kostet 60€ ohne MwSt +15€ Versand
* 2Stück 64€ ohne MwSt +15€ Versand
* 10Stück 90€ ohne MwSt +15€ Versand
* Eurokarte einseitig ohne Lötstopp und ohne Bestückungsdruck kosten 10Stück 71€ ohne MwSt +19€ Versand

==== PCBPro ====
Homepage http://www.pcbpro.com/ (USA)
* Bei größeren Mengen (z. B. 100 Stück) sehr niedrige Preise

==== Top-Tec-PCB ====

'''Geschäftsbetrieb eingestellt'''

Homepage http://www.top-tec-pcb.com/ (Großbritannien)
* Günstig für Klein- bis Großserien
* Discount bei Nachbestellung
* sehr gute Technik (z. B. 100µm Bohren oder 75µm Leiterbahn)
* deutschsprechender Ansprechpartner
* liefern bleifreie Platinen (HAL, chem. Gold, Silber u. Zinn)
* 48h Eildienst

==== The PCB Shop ====
Homepage http://www.thepcbshop.com/ (Belgien)
* Für einfache Sachen
* Preisrechner funktioniert nur mit IE

==== PIU-Printex ====
Homepage http://www.piu-printex.at/ (Österreich)
* Bei größeren Mengen (> 20 Stück, einseitig, viele Bohrungen) günstig
* Bearbeitung innerhalb 6 AT
* Telefonische Kontaktaufnahme bei Rückfragen
* Ich war sehr positiv überrascht.

==== Seeed ====
Homepage http://www.seeedstudio.com (China)
* Mindestens 10Stk
* Größe in 5cm Preisrasterung
* 10Stk 5x5 cm 9.9USD => 1USD/Stk
* 4 Lagig 5Stk 5x5 cm 39.90USD => 8USD/Stk
* 4 Lagig 10Stk 5x5 cm 49.90USD => 5USD/Stk
* Blaue, weiße, rote, gelbe, schwarze platinen für 10USD Aufpreis
* Überproduktion wird mit geliefert, bei einer 2cmx1cm Platine wurden 24Stk anstatt 10Stk geliefert.
* Kostenloser Standardversand bei Bestellungen über 50USD

==== smart prototyping ====
Homepage http://smart-prototyping.com/ (China)

* Mindestens 10Stk
* Größe in 5cm Preisrasterung
* Auch 6 lagige boards
* Maximal 30x30cm
* 10Stk 5x5 cm 8.9USD => 0.9USD/Stk
* 500Stk 5x5 cm 132.92USD => 0.27USD/Stk
* 4 Lagig 10Stk 5x5 cm 39.9USD => 4USD/Stk
* 6 Lagig 10Stk 5x5 cm 239.9USD => 24USD/Stk

==== Vi&Rus International ====
Euro 160x100 für Euro 58,- incl. Express-Versand

http://www.vrint-pcb.com (Bulgarien)

* 3 (!) Arbeitstage
* RoHS, ENIG
* 2 Lagen, durchkontaktiert
* Lötstop beideitig
* Bestückungsdruck
* E-Test
* incl. Vereinzelungen (gefräst)
* incl. Versand (1 AT), also am 4. AT geliefert
* Erstklassige Qualität, auch bei Fine-Pitch; schneller, freundlicher Support.

==== PRIONIK ( Österreich ) ====
Homepage: noch in Arbeit

* Erstellung von hochwertigen Folien/Filmen zum selberätzen
* 1,25 € / 1dm² Film, 2,50 € Mindestbestellwert (Stand September 2013)
* 2 € Porto Österreich (Stand September 2013)
* 4 € Porto Deutschland (Stand September 2013)
* Leiterplattenfertigung auf Anfrage
Kontakt: office@prionik.at

== Preisvergleichstabellen (Stand Februar 2010) ==

Preise für 1, 2 Europlatinen (160x100), FR4 1.6mm, HAL bleifrei, 150µm Leiter, 0.3mm Bohren, doppelseitig, 8AT, kein Bestückungsdruck, inkl. MwSt, ohne Versand.

{| class="wikitable" cellspacing="0" cellpadding="5" align="center" style="text-align:center"
|-
!style="text-align:left" |Hersteller !!Preis (€) 1x !!Preis (€) 2x
|-
|style="text-align:left" colspan="3" |''ohne Lötstopp, ohne E-Test''
|-
|style="text-align:left" |'''Basista Leiterplatten'''|| 43,66 || 81,61
|-
|style="text-align:left" |'''Fischer Leiterplatten GmbH''' (10AT, immer mit LS.+E-T.)|| 46,41 || 73,07
|-
|style="text-align:left" |'''HAKA Elektronik-Leiterplatten GmbH'''|| 64,54 || 106,13
|-
|style="text-align:left" |'''LEITON'''|| 54,98 || 104,51
|-
|style="text-align:left" |'''MME-Leiterplatten''' (200µm Leiter)|| 41,44 || ?
|-
|style="text-align:left" |'''PCB Pool'''|| 50,27 || 100,54
|-
|style="text-align:left" |'''Q-print/Q-PCB'''|| 55,62 || 95,89
|-
|style="text-align:left" colspan="3" |''mit Lötstopp, mit E-Test''
|-
|style="text-align:left" |'''Basista Leiterplatten'''|| 77,66 || 115,61
|-
|style="text-align:left" |'''Fischer Leiterplatten GmbH''' (10AT)|| 46,41 || 73,07
|-
|style="text-align:left" |'''LEITON'''|| 88,79 || 147,39
|-
|style="text-align:left" |'''Multi PCB Ltd. Leiterplatten''' (6AT)|| 78,06 || 156,13
|-
|style="text-align:left" |'''M & V Leiterplatten - Vertriebs GmbH'''|| 62,83 || 125,66
|-
|style="text-align:left" |'''Onlineshop WEdirekt'''|| 128,75 || 172,38
|}

Preise für 1, 2, 10 Europlatinen (160x100), FR4 1.6mm, HAL bleifrei, 150µm Leiter, 0.3mm Bohren, doppelseitig, 8AT, 1x Bestückungsdruck, 2x Lötstopp, E-Test, inkl. MwSt, ohne Versand.

{| class="wikitable" cellspacing="0" cellpadding="5" align="center" style="text-align:center"
|-
!Hersteller !! Preis (€) 1x !!Preis (€) 2x !!Preis (€) 10x !! Nachbest. (€) 10x
|-
|style="text-align:left" colspan="5" |''mit Lötstopp, mit Bestückungsdruck, mit E-Test''
|-
|style="text-align:left" |'''Fischer Leiterplatten GmbH''' (10AT)|| 58,31 || 84,97 || 337,72 || 219,91
|-
|style="text-align:left" |'''HAKA Elektronik-Leiterplatten GmbH'''|| 82,54 || 124,13 || 302,08 || 284,08
|-
|style="text-align:left" |'''LEITON'''|| 124,37 || 187,15 || 389,84 || x
|-
|style="text-align:left" |'''Multi PCB Ltd. Leiterplatten'''|| 78,06 || 156,13 || 272,27 || 180,64
|-
|style="text-align:left" |'''M & V Leiterplatten - Vertriebs GmbH'''|| 110,43 || 173,26 || ? || ?
|-
|style="text-align:left" |'''PCB Pool'''|| 122,29 || 129,26 || 407,58 || x
|-
|style="text-align:left" |'''Q-print/Q-PCB'''|| 96,80 || 166,90 || 834,48 || x
|-
|style="text-align:left" |'''Onlineshop WEdirekt'''|| 145,18 || 190,64 || 379,49 || x
|}

[http://www.jackaltac.com/faq --> grafischer Vergleich der Platinenkosten]

== Lohnbestücker - Kleinserien ==

==== kessler systems GmbH ====
Homepage: http://www.kesslersystems.de
* SMD bis 0201, THT
* BGAs
* macht auch Großserien
* 5 Tage ab Eingang aller Bauteile, Express möglich

==== PCB Pool ====
Homepage: http://www.pcb-pool.com/ppde/info_pcb_assembling.html
* Prototyp & Kleinserien, Größere Stückzahlen auf Anfrage
* SMD bis 0402, THT
* 5 Tage ab Eingang aller Bauteile

==== REDER Domotic GmbH ====
Homepage: http://reder.eu
* Prototypen, Kleinserie, Serie
* THT, SMD ab 0201 Baugröße
* Komplette Materialbeschaffung
* Prototypen über Nacht möglich
* riesen Vorteil: der Mann an der Maschine ist selbst Entwickler

==== riese electronic GmbH ====
Homepage: http://www.riese-electronic.de/leistungen_prototype.html
* SMD bis 0201, THT
* BGAs inkl Röntgen
* macht auch Großserien
* 5 Tage ab Eingang aller Bauteile, Express möglich

==== D-E-K Dischereit GmbH & Co. KG ====
Homepage: http://www.dischereit.de
* Prototyp, Kleinserien, Serie
* SMD bis 0402, THT
* Bauteilbeschaffung

==== PBS-Electronic ====
Homepage: http://www.pbs-electronic.de
* Prototyp, Kleinserien, Serie
* BGA, QFN, TQPF, Fine Pitch, SMD bis 0402, THT
* Einzel IC Bestückung möglich
* Spezialist für LED Technik

==== Traffitec ====
Homepage:http://www.traffitec.de/
* Standort: Hervorster Str. 175, 47574 Goch [http://www.openstreetmap.de/karte.html?zoom=17&lat=51.6904&lon=6.14378&layers=B000TT Link zur Openstreetmap Karte]
* Bestückt Prototypen, Kleinserien, Normalserien
* In THT, SMD und gemischt.
* und von allen Seiten
* Einpresstechnik
* Starrflex
* Komponentenbau

== Siehe auch ==
* [http://www.cadsoft.de/services/board-houses/?language=de Übersicht von Cadsoft, sortiert nach PLZ]
* [http://www.mikrocontroller.net/topic/245590 Forum: Platinensammler - Leiterkarten für 30ct/cm²]

[[Category:Platinen| ]]
[[Kategorie:Lieferanten]]
[[Kategorie:Listen]]

Olimex AT91SAM7X256-Board SAM7-EX256

2013-09-28T00:32:00Z

Mthomas: Schützte „Olimex AT91SAM7X256-Board SAM7-EX256“: Wiederholtes Einstellen von Werbung ([Bearbeiten=Nur automatisch bestätigten Benutzern erlauben] (bis 28. März 2014, 01:32 Uhr (UTC)) [Verschieben=Nur automatisch bestätigten Benutzern erlauben]

[http://shop.mikrocontroller.net/csc_article_details.php?saArticle%5BID%5D=80 Olimex AT91SAM7X256-Board (SAM7-EX256)]

[http://shop.mikrocontroller.net/csc_article_details.php?saArticle%5BID%5D=80 http://shop.mikrocontroller.net/images/sam7-ex256-small.jpg]

== Softwarevoraussetzungen ==

Die folgenden Anleitungen setzen das Vorhandensein einer [[ARM#Compiler|ARM-GCC-Toolchain]] voraus.

== Minimalbeispiel ==

Dieses einfache Beispielprojekt mit Makefile basiert auf dem GCC-Tutorial von Atmel. Enthalten ist kein OS, nur ein paar Funktionen für UART-Kommunikation.

Download: http://www.mikrocontroller.net/attachment/25724/Olimex_SAM7_EX256_StartupMinimal_2007.08.17.zip

== Installation von FreeRTOS ==

Merkmale von FreeRTOS:
* präemptives Multitasking
* Unterstützung für viele Prozessoren und Controller
* Demos für viele verschiedene Boards enthalten
* Beispiele für die Anbindung verschiedener IP-Stacks enthalten (lwIP, uIP)
* Codequalität der Demos durchwachsen

Funktionsumfang des Beispielprojekts:
* TCP/IP-Stack lwIP
* Webserver
* virtueller serieller Port über USB realisiert (CDC, Windows-Treiber enthalten)

Als Ausgangspunkt dient das Beispiel "lwIP_Demo_Rowley_ARM7" aus [http://www.freertos.org FreeRTOS] 4.4.0. Die für das Olimex-Board angepasste (und ein bisschen aufgeräumte) Version kann man [http://www.mikrocontroller.net/attachment/25551/lwIP_Demo_olimex.zip hier] herunterladen. Die Datei muss in den Demo-Ordner von FreeRTOS entpackt werden. Die Änderungen gegenüber der Originalversion sind in der Datei changes.txt dokumentiert.

Die IP-Adresse ist standardmäßig auf 192.168.0.111 gesetzt und lässt sich in der Datei BasicWEB.c ändern.

Kompiliert wird das Projekt wie üblich durch Eingabe von <code>make</code>.

== Installation von Ethernut ==

Ethernut bzw. Nut/OS ist ein Betriebssystem mit TCP/IP-Stack, das ursprünglich für AVR-Controller entwickelt wurde, später aber u.a. auf ARM portiert wurde.

Merkmale von Nut/OS:
* sehr sauberer und gut kommentierter Code
* Buildsystem mit Konfigurations-GUI; Vorteil: einfacher Einstieg, Nachteil: Gesamtsystem manchmal etwas undurchsichtig
* nur kooperatives Multitasking
* zielt hauptsächlich auf AVR ab, ARM-Unterstützung noch nicht weit fortgeschritten
* im Vergleich zu lwIP spartanischer IP-Stack

Funktionsumfang des Beispielprojekts:
* verschiedene Netzwerk-Beispielanwendungen (HTTP, FTP, DHCP)
* serieller Port

Getestet wurde diese Anleitung mit der Ethernut-Version 4.2.1.

Als Ausgangspunkt dient die Konfiguration at91sam7x-ek.conf. Für das Olimex-Board sind ein paar kleine Änderungen nötig.

=== PHY-Konfiguration ändern ===

Unter Architecture/ARM/AT91 EMAC Driver: [[Bild:olimex-sam7x-ethernut-phy-conf.png]]

=== PHY-Initialisierung patchen ===

In der Funktion EmacReset in der Datei at91_emac.c den Block mit dem Kommentar <code>/* For some unknown reason...</code> durch folgenden Code ersetzen:

<syntaxhighlight lang="c">
/* PHY ID */
#define MII_DM9161_ID_H 0x0181
#define MII_DM9161_ID_L 0xb8a0

#define MII_AM79C875_ID_H 0x0022
#define MII_AM79C875_ID_L 0x5540

#define MII_MICREL_ID_H 0x0022
#define MII_MICREL_ID_L 0x1610

/* For some unknown reason it seems to be required to read the ID registers first. */
// Check for DM PHY (as used on the ATMEL EK)
if (phy_inw(NIC_PHY_ID1) != MII_DM9161_ID_H ||
(phy_inw(NIC_PHY_ID2) & 0xFFF0) != MII_DM9161_ID_L) {
// Check for MICREL PHY (as used on the Olimex SAM7-EX256)
if (phy_inw(NIC_PHY_ID1) != MII_MICREL_ID_H ||
(phy_inw(NIC_PHY_ID2) & 0xFFF0) != MII_MICREL_ID_L) {
outr(EMAC_NCR, inr(EMAC_NCR) & ~EMAC_MPE);
return -1;
}
}
</syntaxhighlight>

=== Fehlende Definition ergänzen ===
Falls eine Fehlermeldung auftritt dass EMAC_PIO_SODR nicht definiert ist, folgenden Code in der Datei at91_emac.c vor <code>#ifdef PHY_PWRDN_BIT\n /* Disable PHY power down. */</code> einfügen:

<syntaxhighlight lang="c">
#ifndef EMAC_PIO_SODR
#define EMAC_PIO_SODR PIOB_SODR
#endif
</syntaxhighlight>

=== Ausprobieren ===

Wenn man das Beispielprogramm httpserv kompiliert (<code>make</code> eingeben) und in den Controller geladen hat sollte man über das UART (115.2 kBaud) die erfolgreiche Initialisierung bestätigt bekommen:
Nut/OS 4.2.1 HTTP Daemon...Configure eth0...OK
192.168.0.21 ready

Jetzt kann man die angezeigte IP-Adresse im Browser eingeben und sollte die Testseite zu sehen bekommen.

== Forum ==
* [http://www.mikrocontroller.net/topic/75721#new Diskussion zum Thema]

== Weblinks ==
* http://www.sparkfun.com/tutorial/Nokia%206100%20LCD%20Display%20Driver.pdf

[[Category:ARM-Boards]]

PHILIPS VP5500 VoIP Telefon

2013-08-03T09:21:50Z

Mthomas: Schützte „PHILIPS VP5500 VoIP Telefon“: Wiederkehrender Vandalismus ([Bearbeiten=Nur automatisch bestätigten Benutzern erlauben] (bis 3. Februar 2014, 10:21 Uhr (UTC)) [Verschieben=Nur automatisch bestätigten Benutzern erlauben] (bis 3. Februar

= Verwandte Artikel =
* Konfiguration: http://www.mikrocontroller.net/topic/170483#new
* Kernel/GUI Entwicklung: http://www.mikrocontroller.net/topic/172616#new
* http://das-labor.org/wiki/VP5500
* (Hack) http://spritesmods.com/?art=vpx500
* http://vp6500.bd8.nl/

= Allgemeines =

Bei den diesem Text zugrundeliegenden Geräten handelt es sich um videofähige VoIP-Phones des Herstellers Philips, die vom früheren holländischen Anbieter KPN vertrieben wurden und nach dessen Ausscheiden aus dem Markt nun günstig erhältlich sind.
Ihr geringer Preis, die SoC-Architektur und das darauf laufende OS macht sie dabei für all jene interessant, die ihre eigenen Ideen und Projekte auf der Basis eines solchen Gerätes verwirklichen wollen, und gibt den oft fabrikneuen Exemplaren eine Art zweite Chance.

== Features ==

=== VP5500 ===
* Kamera-Auflösung 640x480 Pixel
* 30 Bilder pro Sekunde
* Kamera um 240° drehbar
* 5,6 cm (2,2") TFT-Display, 176x220 Pixel, 65000 Farben
* Audio-/Video-Ausgang - 4fach 2,5mm Klinke-Cinch
* integrierter Li-Ion Akku, 3,7 V-/1100 mAh
* englische und niederländische Menüsprache
* Software Qtopia Version 2.1.0
* Maße (LxBxH): 134x49x24 mm.

[[Datei:Philips_VP5500.jpg]]

=== VP6500 ===

* Kamera-Auflösung 640x480 Pixel
* 30 Bilder pro Sekunde
* Kamera um 240° drehbar
* 5,6 cm (2,2") TFT-Display, 176x220 Pixel, 65000 Farben
* Audio-/Video-Ausgang - 4fach 3,5mm Klinke-Cinch
* 2x Philips Multilife AA/R6NM 1800mAh NiMH-Akkus, je 1,2V, Ladeempfehlung: 15h mit 180mAh
* englische, deutsche und niederländische Menüsprache
* Software Qtopia Version 2.1.0
* Maße (LxBxH): 134x49x24 mm.
* Gewicht Mobilteil: 170 g (inkl. 2 NiMH-Akkus AA)
[[Bild:VP6500_kl.jpg]]

= Das VPx500 'rooten' =

Um vollen Zugang zum System auf dem Gerät zu erhalten gibt es mehrere Möglichkeiten.

== per telnet ==
Sobald das Telefon im Netzwerk angemeldet ist (egal ob DHCP oder statisch) kann über irgendein Terminal vom Netzwerk aus via telnet und der Telefon-IP auf das Gerät zugegriffen werden.
User: root / PW: toor

== per serieller Schnittstelle ==
Dazu muß der [[#UART]] angeschlossen werden. Während des Bootvorgangs drückt man immer wieder ziellos irgendwelche Tasten bis man am Prompt des [http://www.lartmaker.nl/lartware/blob/ blob-Bootloaders] ist.
Dann kann man
boot root=/dev/mtdblock2 init=/bin/sh
eingeben, um an eine minimale Shell zu kommen.

In dieser setzt man dann mit
passwd
das Passwort für ''root''. Danach kann man sich als ''root'' mit dem gesetzten Passwort einloggen.

== per DNS-Hack ==
Um den Rootzugriff zu aktivieren, wird dem Telefon ein Softwareupdate vorgegaukelt. Es versucht, auf den Updateserver von KPN zuzugreifen (den es nicht mehr gibt). Glücklicherweise geschieht dies nicht über eine feste IP, sondern über einen Hostnamen, so dass man an dieser Stelle sich durch einen eigenen DNS den Domainname auf einen eigenen Server umleiten kann. Daher ist im eigenen Netzwerk eine Umleitung des DNS erforderlich (oder ein DHCP-Server, der die Adresse des DNS bekanntgibt. Stichworte 'Static DNS', ..).
Das Gerät holt sich dann ein Updatepaket, das den Telnet-Zugang aktiviert.

Dann lässt sich per Terminal (Linux. Windows: ....) die Kommandozeile des Geräts aufrufen:

telnet 123.456.789.012

Passwort ist "toor".
Das Ändern des root-Passwortes erfolgt mit dem Befehl passwd.

Unter Applications>Registration sind Netzwerk- und VoIP-Einstellungen zu finden.

=== Anleitung für Fritz-Box-Benutzer ===
Die Fritzboxen bieten bisher leider keine Möglichkeit, den verwendeten DNS
direkt im Webinterface zu ändern, über Umwege geht es aber doch:
* Über das Webinterface der Fritzbox die Einstellungen sichern
* Exportdatei im Texteditor öffnen (am besten nicht Notepad, da der die Unix-Zeilenumbrüche nicht versteht - zur Not geht auch Wordpad)
* nach overwrite_dns1 suchen (gibt es zwei mal) und da den DNS 84.38.68.30 (von blooza http://www.mikrocontroller.net/topic/170483#1651124 bereitgestellt) oder 188.40.123.50 (von sprites http://spritesmods.com/?art=vpx500 bereitgestellt) eintragen
* am Anfang der Exportdatei VOR "**** CFGFILE:ar7.cfg" eine Zeile 'NoChecks = yes' einfügen, damit die Fritzbox die nun nicht mehr passende Checksumme ignoriert.
* Einstellungen zurück in die Fritzbox übertragen.

Wenn die Telefone entsperrt sind, den DNS wieder entfernen (Es ist
vielleicht eine ganz gute Idee, wenn man da zwei unabhängige DNS-Server
einträgt, so umgeht man auch gleich providerseitige DNS-Sperren)

==== Alternative ====
Wer sich den nicht ganz ungefährlichen Weg mit den anpassungen an der Fritzbox erspahren will, wechselt seine Fritzbox in den Expertenmodus. Danach kann man unter System - Netzwerk bei dem Punkt "IP adresse der Fritzbox ändern" bei vielen modellen den internen DHCP abschalten. Dann unter windows z.B. tftpd32 (http://tftpd32.jounin.net/) starten, in dessen DHCP-Server die Fritzbox als Gateway und den entsprechenden "modding-dns" eintragen und das Telefon neustarten.

War das Telefon schonmal angemeldet, versucht es die selbe IP vom neuen DHCP zu erzwingen, was tftpd32 nicht wirklich mag. Daher im tftpd32 die lease-ip bei 2 beginnen lassen und eine range von 250 eintragen, damit die vom Telefon verlangte IP auch im Adresspool des dhcp servers vorhanden ist.

=== Anleitung fli4l ===
Mit dem [http://www.fli4l.de fli4l] ist das ganze ganz einfach.

In der Datei config/dns_dhcp.txt den DNS Redirect für die zwei DNS-Name Konfigurieren.

<file>
 DNS_REDIRECT_N='2' # number of redirected domains
 DNS_REDIRECT_1='ntp.xs4all.nl' # 1st redirected domain
 DNS_REDIRECT_1_IP='188.40.123.50' # IP of redirected domain

 DNS_REDIRECT_2='vpcm-001.cust.kpn.net'
 DNS_REDIRECT_2_IP='188.40.123.50'
</file>

= Hardware =

== verwendete Komponenten ==

* MCU: [http://www.mikrocontroller.net/attachment/72258/datasheet.pdf Freescale MC9328MX21] (ARM9) @ 266MHz ([http://en.wikipedia.org/wiki/I.MX21 Wikipedia_englisch])
** gehört zur ARM9E-Familie: ARMv5TEJ -"IntructionSet" (ARM926EJ-S)
** [http://www.freescale.com/files/32bit/doc/ref_manual/MC9328MX21RM.pdf MC9328MX21 Applications Processor Reference Manual]
* PC-to-TV-Konverter-Chip: [http://www.mikrocontroller.net/attachment/73579/Data_Sheets.zip FS455LF]
* WLAN: Marvell 88w8385, als Modul von [http://www.mikrocontroller.net/attachment/72802/WM-G-MR-01-v27__01192006.pdf WM-G-MR-01] (VP5500) / Philips [http://www.mikrocontroller.net/attachment/73812/BGW211_Preliminary_Datasheet_v1.1.pdf BGW211], on-board (VP6500)
* SDRAM: 2 x [http://www.mikrocontroller.net/attachment/72461/K4S56163LF.pdf K4S56163LF] - 4M x 16Bit x 4 Banks im VP5500
* SDRAM: 1 x [http://www.mikrocontroller.net/attachment/73520/Samsung_64MB_K4M51323PC_1_8V.pdf K4M51323PC_1_8V] - 4M x 32Bit x 4 Banks im VP6500
* Flash: 2 x ws128j0pbfw00 [http://www.mikrocontroller.net/attachment/72462/S29WS064J.pdf S29WS128J/064J] 128/64 Megabit (8/4 M x 16-Bit) CMOS 1.8 Volt-only Simultaneous Read/Write, Burst Mode Flash Memory im VP5500
* Flash: 1 x [http://www.mikrocontroller.net/attachment/73521/S29GL512N.pdf S29GL512N] - 512 Megabit, 3.0 Volt-only Page Mode Flash Memory im VP6500
* Kamera: dc-4626.a5 by chicony
* Display: Samsung LTS220QC (HD66772 Controller)

== Messungen ==

=== Stromaufnahme ===

==== VP5500 ====
FIXME

==== VP6500 ====

Konfiguration: VP6500 mit aktivierter serieller Konsole an Labornetzteil, Spannung 3.67V (Bei weniger bootet es anscheinend aufgrund von Stromspitzen nicht richtig und vermeldet auf der seriellen Konsole ein 'battery low' und schaltet sich danach selbst ab. Diese Spannung sollte noch so gerade 'safe' sein, geht man davon aus, daß da ein Step-Up im Innern am werkeln ist und noch ein geringer Abfall über die Schottky-Diode einzurechnen ist).

===== Telefon =====
* Booten: bis zu 420mA
* Einbuchen: ca. 400mA
* mit abgeschaltetem Display, aber eingebucht und laufend (idle): ca. 80mA
* mit angeschaltetem Display, eingebucht und idle: ca. 190mA
* mit 100% Prozessor-Last (von serieller Konsole ausgeführt: "while true; do true; done"): ca. 60mA mehr als idle (Scheint aber auch größere Sprünge für andere CPU-Last zu geben)
* im 'Deep Sleep' (wird ein paar Minuten nach Einschalten erreicht): <10mA (!), mit kurzen Wachphasen mit erheblichem Stromverbrauch (>100mA). Beachte: Die serielle Konsole ist in diesem Modus auch nicht mehr aktiv, das Telefon ist aber nicht abgestürzt (Tastendruck aktiviert die Konsole wieder).
* Telefonieren ca 500mA
* Telefonieren mit Webcam ca 550mA

===== Ladegerät =====
* Phone nicht in der Ladeschale: < 0.2W
* Phone wird geladen: ca 4W

== System-Takte ==
# cat /proc/systclk
System clocks state:
 Ref clock : 32768Hz (int, premult by 512)
 MPLL clock: 263999905Hz (computed: 264000000Hz)
 SPLL clock: 163840000Hz (computed: 163840000Hz)
 CPU clock : 263999905Hz (PERSC = 0)
 Bus clock : 132000000Hz (BCLKDIV = 1, computed: 131999952Hz)
 CSI clock : unknown (cannot read register CSICR1)
 USB clock : 20480000Hz (USB_DIV = 7)
 Wait State: CS0U[WSC] = 10, CS0U[WSC] = 48
 loops_per_jiffy = 665058

== Innenleben ==

=== Zerlegen des VP5500 ===
<gallery>
Datei:01_offen_von_Hinten.JPG|1. Geöffnetes Akkufach
Datei:02_Blende_entfernt.JPG|2. hintere Schwarze Blende entfernt
Datei:03_Rückseite_entfernt.JPG|3. Schalenrückteil entfernt
Datei:04_aufhebeln_Vorderteil.JPG|4. Druck nach außen
Datei:05_vorderteil_entfernt.JPG|5. entferntes Vorderteil
Datei:06_Elektronik_entfernt.JPG|6. entfernte Elektronik
</gallery>

# das Akkufach muss geöffnet und die Schrauben entfernt werden
# hinter der rückseitigen schwarzen Blende befinden sich zwei Schrauben, die entfernt werden müssen
#* Hierzu am besten mit einem schmalen kleinen Schraubendreher von der Stirnseite aus zwischen die Plastikteile fahren und vorsichtig aufhebeln und den Schraubendreher dabei weiter unter die Blende bewegen.
# Nun kann einfach das rückseitige Schalenteil abgeschaubt werden
# das Entfernen des Frontschalenteils ist etwas tricky:
#* von oben und unten lässt sich ganz gut ein Spalt zur Seite aufweiten
#* etwas unter der Mitte hängt es aber auf beiden Seiten. Dort befinden sich kleine Plastikbügel, die recht leicht zerbrechen.
#* Mit einem sehr schmalen Schraubendreher in eine der Lücken fahren (anfangen auf der Seite ohne Tasten) und den Schraubendreher nach innen drücken, so das der Druck in der Seite nach außen wirkt.
#* Mit etwas Geschick bekommt man das so ohne Bruch ab, es ist aber auch nicht kritisch, wenn der Bügel ein wenig anbricht)
# Die Platine zu entfernen ist nicht ganz so schwierig.
#* Zuerst die Seite auf der keine Knöpfe sind:
#* vorsichtig diese Seite leicht anheben. Am unteren Ende ist auf die Kontakte zu achten
#* dann versuchen die Platine seitlich nach oben aus dem Gehäuse zu ziehen
#* dabei auf das Lautsprecherkabel und den Kamerakonnektor achten
# Zusammenbau genauso, nur umgedreht ;)
#* nicht die Lautsprecher- und Kamera-Stecker vergessen

=== Bilder vom VP5500 Innenleben ===
<gallery widths="240" >

Datei:Oberseite.jpg | Ansicht der Oberseite
Datei:Oberseite_beschriftet.jpg | Oberseite mit Beschriftung der Bauteile
Datei:Drumherum.jpg | Übersicht über die Komponenten
</gallery>

<gallery widths="240" >
Datei:Kontakte_Oberseite.jpg | UART-Schnittstelle Oberseite
Datei:Kontakte_Unterseite.jpg | JTAG-Schnittstelle Unterseite
</gallery>

=== Testpins am VP5500 ===
Original Liste von [http://www.mikrocontroller.net/topic/170483#1646514 Tino] [[Media:Philips vp5500 Liste Testpins.pdf|herrunterladen]].

[[Bild:Philips vp5500 testpins 1.jpg|thumb| Testpins auf der Rückseite]]
[[Bild:Philips vp5500 testpins 2.jpg|thumb| Frontseite: Die ICs wurden zum Messen ausgelötet.]]

{| class="wikitable"
! Testpin Nr. !! verbunden zu !! Funktion
|-
| 1 || LED || unbekannt
|-
| 2 || Kamera Pin 8 an CN1 || unbekannt
|-
| 3 || Pin 4 an IC1 || unbekannt
|-
| 4 || z.B. IC5 Pin V 18 || VDDA
|-
| 5 || GND || GND
|-
| 6 || NC || NC
|-
| 7 || Pin E 16 an IC5 || SAP_CLK
|-
| 8 || Pin 1 an CN 3 || Lautsprecher
|-
| 9 || Pin 2 an CN 3 || Lautsprecher
|-
| 10 || Pin an CN 4 || ?
|-
| 11 || Pin an CN 4 || ?
|-
| 12 || Pin an CN 4 || ?
|-
| 13 || Pin L 16 an IC5 || UART2_TXD
|-
| 14 || Pin C 12 an IC5 || USBH1_RXDM
|-
| 15 || Pin H 12 an IC5 || USBH1_TXDP
|-
| 16 || Pin B 19 an IC5 || CSPI2_SS2
|-
| 17 || Pin B16 an IC5 || SSI2_FS
|-
| 18 || Pin F 18 an IC5 || KP_ROW0
|-
| 19 || Pin K 18 an IC5 || KP_COL4
|-
| 20 || Pin L 19 an IC5 || UART3_TXD
|-
| 21 || Pin T 14 an IC5 || RESET_IN
|-
| 22 || geht an + des Kondensators neben IC6 || unbekannt
|-
| 23 || Pin D 13 an IC 9 || CLKOUT
|-
| 24 || Pin E 13 an IC 9 || CLKIN_P
|-
| 25 || Pin A 9 an IC 9 || DAC_D
|-
| 26 || Pin A 8 an IC 9 || DAC_A
|-
| 27 || Pin A 7 an IC 9 || DAC_B
|-
| 28 || Pin A 6 an IC 9 || DAC_C
|-
| 29 || Pin L 13 an IC 5 || UART1_TXD
|-
| 30 || Pin T 16 an IC 5 || BOOT1
|-
| 31 || Pin K 10 an IC 5 || UART1_RXD
|-
| 32 || Pin U 17 an IC 5 || BOOT2
|-
| 33 || Pin 9 an IC 23 || unbekannt
|-
| 34 || Pin D 19 an IC5 || CSPI2_SCLK
|-
| 35 || Pin C 14 an IC5 || TIN
|-
| 36 || Pin C 19 an IC5 || CSPI2_SS1
|-
| 37 || Pin D 18 an IC5 || CSPI2_SS0
|-
| 38 || Pin E 19 an IC5 || CSPI2_MOSI
|-
| 39 || Pin H 19 an IC5 || PWMO
|-
| 40 || Pin J 9 an IC 7 und IC 8 || VDD
|-
| 41 || Pin J 19 an IC 5 || KP_COL2
|-
| 42 || Pin K 16 an IC 5 || KP_COL3
|-
| 43 || Pin J 11 an IC 5 || KP_ROW2
|-
|44 || Pin J 17 an IC 5 || KP_COL1
|-
|45 || Pin G 19 an IC 5 || KP_ROW4
|-
|46 || Pin G 17 an IC 5 || KP_ROW3
|-
|47 || Pin D 5 an IC 10 und IC 11 || ACC
|-
|48 || Pin G 16 an IC 5 || KP_ROW1
|-
|49 || Pin J 18 an IC 5 || KP_COL0
|-
|50 || Pin V 18 an IC 5 || VDDA
|-
|51 || Pin 2 an CN KB-Stecker || ?
|-
|52 || Pin 2 an IC 15 || ?
|-
|53 || Pin 4 am LCD Stecker || ?
|-
|54 || Pin E 17 an IC 5 || CSPI2_MISO
|-
|55 || Pin 1,2,3,10,13 am LCD Stecker || ?
|-
|56 || Pin 3 an IC 16 || ?
|-
|57 || Pin U 10 an IC 5 || PC_PWRON
|-
|58 || Pin 1 IC 18 || ?
|-
|59 || an Diode über IC 16 || ?
|-
|60 || Pin 3 an IC 25 || ?
|-
|61 || Ladekontakt positiv || Ladegerät +
|-
|62 || GND || GND
|-
|63 || Akku Mittelkontakt || Akkustand? Temperatur?
|-
|64 || Transistor unter IC 16 || ?
|-
|65 || Pin 2 an IC 22 || ?
|-
|66 || Pin 1,12,30 an IC 24 || VSS
|-
|67 || Kondensator + unter IC 20 || ?
|-
|68 || Pin 5 an IC 21 || ?
|-
|69 || Pin 2 an IC 4 || ?
|-
|70 || Pin 25 an IC24 || MCLK
|-
|71 || Prozessor Pin W 14 || QVDD
|}

=== Testpins am VP6500 ===
Original Listen von [http://www.mikrocontroller.net/topic/170483#1658720 Tino] herunterladen. [[Media:V6500_Back.xls|Rückseite]], [[Media:V6500_Front.xls|Vorderseite]].

[[Bild:V6500_Back.jpg|thumb| Testpins auf der Rückseite]]

{| class="wikitable"
! Testpin Nr. !! verbunden zu !! Funktion
|-
| 1 || Pin 21 an BGW211EG || POR_N
|-
| 2 || Pin A 14 an i.MX21 || TOUT
|-
| 3 || Pin 46 an BGW211EG || JTAG_TDI
|-
| 4 || Pin 44 an BGW211EG || JTAG_TCLK
|-
| 5 || Pin 42 an BGW211EG || JTAG_TDO
|-
| 6 || Pin 47 an BGW211EG || JTAG_TRST_N
|-
| 7 || PIN 45 an BGW211EG || JTAG_TMS
|-
| 8 || Pin 43 an BGW211EG || JTAG_RTCLK
|-
| 9 || Pin C 14 an i.MX21 || TIN
|-
| 10 || VDD || VDD
|-
| 11 || Pin K 10 an i.MX21 || UART1_RXD
|-
| 12 || Pin L 13 an i.MX21 || UART1_TXD
|-
| 13 || GND || GND
|-
| 14 || Pin U 17 an i.MX21 || BOOT2
|-
| 15 || Pin V 16 an i.MX21 || BOOT0
|}

[[Bild:V6500_Front.jpg|thumb| Frontseite: Die ICs wurden zum Messen ausgelötet.]]

{| class="wikitable"
! Testpin Nr. !! verbunden zu !! Funktion
|-
| 1 || Pin 29 von BGW211EG & F 16 an i.MX21 || RESET_N / CSPI1_SS1
|-
| 2 || Pin 28 an BGW211EG & J 12 an i.MX21 || SPI_DAT_MOSI / CSPI1_MOSI
|-
| 3 || Pin 27 an BGW211EG & F 19 an i.MX21 || SPI_SS_N / CSPI1_SS0
|-
| 4 || Pin 26 an BGW21EG & F 17 an i.MX21 || SPI_DAT_MISO / CSPI1_MISO
|-
| 5 || Pin 25 an BGW211EG & H 10 an i.MX21 || SPI_CLK / CSPI1_SCLK
|-
| 6 || Pin 24 an BGW211EG & H 11 an i.MX21 || SPI_EXT_INT / CSPI1_RDY
|-
| 7 || Pin 41 an BGW211EG || UART_TX
|-
| 8 || Pin 40 an BGW211EG || UART_RX
|-
| 9 || Transistor unter Testpunkt || ?
|-
| 10 || GND || GND
|-
| 11 || LED || ?
|-
| 12 || Pin 8 am Kamerastecker || ?
|-
| 13 || Pin 18 am Kamerastecker || ?
|-
| 14 || Pin E 13 & H12 an FS455 || CLKIN / PREF
|-
| 15 || Pin D 13 an FS455 || CLKOUT
|-
| 16 || Pin A 11 an FS455 || XTAL_OUT
|-
| 17 || VDD von FS455 || VDD
|-
| 18 || Pin 15 & 16 am Displayconnector || ?
|-
| 19 || geht an 2 Dioden links daneben || ?
|-
| 20 || Pin M 19 an i.MX21 || UART1_CTS
|-
| 21 || Pin M 18 an i.MX21 || UART1_RTS & GND ??
|-
| 22 || VDDan i,MX21 || VDD
|-
| 23 || Pin G 10 an i.MX21 || USB_BYP
|-
| 24 || Pin A 19 an i.MX21 || SSI3_FS
|-
| 25 || Pin D 17 an i.MX21 || SSI2_CLK
|-
| 26 || VDD an i.MX21 || VDD
|-
| 27 || Pin T 17 an i.MX21 || SD1_D3
|-
| 28 || Pin A 15 an i.MX21 || SAP_TXDAT
|-
| 29 || GND || GND
|-
| 30 || Pin T 14 an i.MX21 || RESET_IN
|-
| 31 || Pin R 19 an i.MX21 || TRST
|-
| 32 || Pin P 19 an i.MX21 || TMS
|-
| 33 || Pin N 17 an i.MX21 || TCK
|-
| 34 || Pin K 11 an i.MX21 || TDO
|-
| 35 || Pin P 18 an i.MX21 || TDI
|-
| 36 || Pin 13 an TLV320 || OUTP2
|-
| 37 || Pin 14 an TLV320 || OUTMV
|-
| 38 || Pin 15 an BGW211EG || VDD
|-
| 39 || Pin an Klinkenbuchse || ?
|-
| 40 || Pin an Klinkenbuchse || ?
|-
| 41 || ? || ?
|-
| 42 || LED Tastatur || ?
|-
| 43 || LED Tastatur || ?
|-
| 44 || Pin 1,8 an 20XN2512 & Key ON || PowerON
|-
| 45 || Pin 7 an BDR72K || ?
|-
| 46 || Pin 2 an BDR72K || ?
|-
| 47 || Pin 6 an MRRBGB3 || ?
|-
| 48 || LED Tastatur || ?
|-
| 49 || Pin 10 an MRRBG3 || ?
|-
| 50 || LED Tastatur || ?
|-
| 51 || geht an Widerstand auf Rückseite ? || ?
|-
| 52 || Pin L 13 an i.MX21 || UART1_TXD
|-
| 53 || geht an Diode und Kondensator auf der Rückseite || ?
|-
| 54 || Pin C 14 an i.MX21 || TIN
|-
| 55 || geht an Widerstand auf der Rückseite || ?
|-
| 56 || Pin 7 an BDR72K || ?
|-
| 57 || Pin K 10 an i.MX21 || UART1_RDX
|-
| 58 || Pin U 17 an i.MX21 || BOOT2
|-
| 59 || Pin T 16 an i.MX21 || BOOT1
|-
| 60 || geht an Widerstand auf der Rückseite || ?
|-
| 61 || Pin V 16 an i.MX21 || BOOT0
|-
| 62 || LED Tastatur || ?
|-
| 63 || LED Tastatur || ?
|-
| 64 || Pin 25 an TLV320 || MLCK
|-
| 65 || Pin4 an 69W2440D || ?
|-
| 66 || VDD von TLV320 || VDD
|-
| 67 || geht an Widerstand auf der Rückseite || ?
|-
| 68 || geht an Widerstand auf der Rückseite || ?
|-
| 69 || Pin 65 an MRRBG3 || ?
|-
| 70 || GND || GND
|-
| 71 || LED Tastatur || ?
|-
| 72 || LED Tastatur || ?
|-
| 73 || Akku positiv || Plus Akku
|-
| 74 || Ladekontakt positiv || Ladekontakt positiv
|-
| 75 || Akku positiv || Plus Akku
|}

== UART ==
TIN muss auf low gezogen werden, um die Schnittstelle zu aktivieren.
Jedoch startet dann das Telefon nicht vollständig (Fix siehe [[#Betrieb mit aktivierter serieller Schnittstelle]], zum rooten langt es jedoch, siehe [[#per serieller Schnittstelle]])

* Spannungs-Pegel: 3.3V
* Baudrate: 115200 bps
* Stopbits: 1
* Flussteuerung: keine
=== VP5500 ===
[[Bild:VP5500_seriell_highlight.svg|100px|UART-Pins VP5500(Frontseite der Platine)]]

Die serielle Schnittstelle ist unten vom Akkufach aus zugänglich.
Obiges Bild kennzeichnet die für die serielle Kommunikation benötigten Pins.

=== VP6500 ===
[[Bild:VP5600-Serialport-Preliminary.jpg|100px|UART-Pins VP6500]]

Die serielle Schnittstelle ist unten vom Akkufach aus zugänglich.
Obiges Bild kennzeichnet die für die serielle Kommunikation benötigten Pins. 
VCC liefert anscheinend die ungeregelte Akkuspannung, Boot-Pins nicht verifiziert.

== JTAG ==
[[Bild:jtag.jpg Belegung der JTAG-Pins (Rückseite der Platine)]]

== Hardware Modifikationen ==

Nachdem wir ja bereits wissen wie das [[#Zerlegen_des_Telefons]] geht, steht der Nachrüstung von Bauelementen und Schnittstellen generell nichts mehr im Wege.

=== Buchse für UART ins VP5500 einbauen ===
<gallery>
Datei:10_Pins.JPG|1. unbearbeitete Pinreihe
Datei:11_Pins_bearbeitet.JPG|2. präperierte Pinreihe
Datei:09_Pads.JPG|3. präperierte Pads
Datei:12_Pins_ausrichten.JPG|4. Pinreiheausrichten
Datei:13_Pins_angelötet_1.JPG|5. angelötete Pinreihe
Datei:14_Pins_angelötet_2.JPG|6. angelötete Pinreihen
Datei:08_Mittelteil.JPG|7. Mittelteil mit ausgefeiltem Loch
Datei:15_Mittelteil_zusammengebaut.JPG|8. wieder zusammengesteckt
Datei:16_in_Aktion.JPG|9.verbundene serielle Schnittstelle
</gallery>

Zunächst muss das Telefon zerlegt werden ([[#Zerlegen des Telefons]])
Um das Gehäuse nicht zu beeinträchtigen, habe ich mich dazu entschieden, alles so zu lassen wie es ist und nur kleine Buchsen einzubauen.

# Hierfür habe ich einreihige gedrehte IC-Sockel genutzt
# deren Beine abgezwickt, und etwas Lötzinn aufgetragen (mit der langen Reihe kann man die kurzen, schmalen Teile super handhaben)
# ebendso auf die Pads ein wenig eingezinnt
# ausrichten und festlöten
# eine Reihe
# die zweite Reihe
# bei der Gehäuseöffnung über den Pins habe ich mit einer feinen Schlüsselfeile den Rand wenig aufgeweitet. An der Gummimatte hab ich nix geändert.
# fertig
# und im Einsatz

=== Anschluss für UART des VP6500 zugänglich machen ===
Vorteil beim VP6500: es muss dazu nicht zerlegt werden, da sich die Kupferpads unter den Akkus im Akkufach verstecken. Dies ermöglicht eine lötfreie Variante des seriellen Anschlusses. Die Pinbelegung ist unter [[#VP6500_2|UART]] beschrieben.
<gallery>
Datei:01_Kuli-Molex.jpg|1. Benötigte Teile: Stück Plastik + Molex Stecker
Datei:02_gefeiltes_Plastik_18_mm.jpg|2. Länge der Aussparung im Batteriefach: 18 mm
Datei:03_gefeiltes_Plastik_4_mm.jpg|3. Breite der Aussparung im Batteriefach: 4 mm
Datei:04_gefeiltes_Plastik_passt.jpg|4. Solange feilen bis es passt
Datei:05_gefeiltes_Plastik_Kerben.jpg|5. Padabstand markiert
Datei:06_gekerbtes_Plastik_Molex.jpg|6. So bekommt man die Federn aus den Steckern
Datei:07_Federelement_roh.jpg|7. Frisch aus dem Stecker
Datei:08_Federelement_offen.jpg|8. Aufgebogen
Datei:10_Federelement_unter_Plastik.jpg|9. In Plastikführung
Datei:09_Federelement_umgebogen.jpg|10. Umgebogen
Datei:11_halbfertig_passt.jpg|11. Kerbung angepasst?
Datei:12_ganz_fertig1.jpg|12. Mit Heißkleber sichern
</gallery>
*1. Da wir 4 Pole anschließen wollen, benötigen wir 4 federnde Teile aus "Molex"-Steckern, wie man sie aus CPU-Lüftern kennt. (Entweder hat man einen 4-poligen für die modernen PWM geregeltn zur Hand den man ausschlachten kann, oder man nimmt zwei dreipolige alte auseinander.)
*2./3. Ferner braucht man ein Stück Plastik mit den Maßen 4 mm mal 18 mm, welches als Träger für die Federkontakte dienen soll. Die Höhe ist nicht so entscheidend. Man kann z.B. den Clip eines Kugelschreibes passend zuschneiden und feilen.
*4. Plastikträger so weit zufeilen, dass er in die Aussparung passt (Tip: Bindfaden darum knoten um ihn wieder entfernen zu können)
*5. Abstände zwischen den Kontakten die kontaktiert werden müssen (TIN, GND, RX, TX : siehe [[#UART|UART]]) markieren und in die Unterseite des Trägers Führungskerben für die Federn sägen. Ebenso braucht man kleine Aussparungen um die Metallzungen von der Platine in das Batteriefach zu führen.
*6./7. Aus den Molex-Steckern bekommt man die Federn sehr einfach raus, indem man mit einem kleinen flachen Schraubenzieher vorsichtig in die Aussparungen sticht und hinten am Kabel zieht.
*8. Die einzelnen Metallzungen nun noch auf 90° aufbiegen.
*9. In die Führungskerbe einschieben.
*10. Metallzunge umbiegen. (Zange)
*11. Sind alle Kerbungen und Aussparungen richtig abgemessen und gut zugefeilt, dann passt alles in die Lücke im Batteriefach, ohne dass sich die verschiedenen Metallteile berühren.
*12. Mit etwas Schrumpfschlauch und Heißkleiber kann man dem Verrutschen der Metallzungen vorbeugen und die Kurzschlußwahrscheinlichkeit senken. Ferner dient der Heißkleber als Kraftüberträger, damit die Batterien die leicht federnden Metallzungen fest auf die Kontakte auf der Platine drücken können.
*13. Batterien einsetzen. Ohne diese wird das ganze irgendwann doch wieder rausfallen und die Verbindung von Anfang an unzuverlässig sein.

Problembehandlung:
* Kein Kontakt: (Man kann z.B. die Masse auf Durchgang prüfen.)
** Träger nicht tief genug in die Lücke gedrückt: Mit schmalem Schraubenzieher nachdrücken. Meistens auf der Seite notwendig wo die Metallzungen nach oben kommen.
** Träger wird nach aussen gedrückt (Metallzungen federn ja): Mehr Heißkleber um mehr Druck durch die Batterien zu bekommen.
** Träger tief drin, aber trotzdem keine oder unzuverlässige Verbindung: Die Metallzungen auf der Unterseite haben verschiedene "Dicken", oder die Kerben sind unterschiedlich tief. Ein Tropfen Lötzinn auf die zu niedrigen Metallzungen erledigt dies. (Anmerkung: Der Autor musste überall ein wenig Lötzinn auftragen um die notwendige Dicke und sichere Verbindung zu erreichen.)

= Nutzung für Voice over IP (VoIP, SIP) =

== weiterführende Links ==

*http://de.wikipedia.org/wiki/IP-Telefonie
*http://de.wikipedia.org/wiki/Session_Initiation_Protocol
*http://de.wikipedia.org/wiki/H.323
*http://de.wikipedia.org/wiki/Softphone

Benutzer ist 103

Mit [http://ekiga.org Ekiga] konnte so per 103@xxx.xxx.xxx.xxx bei ersten Tests eine Sprachverbindung zum Telefon aufgebaut werden.

== SIP Einstellungen ==

Die SIP Einstellungen können alternativ auch direkt in der Datei
/user_data/data/hpr0userparam.cfg
vorgenommen werden.

=== Einstellung für 1und1 ===

* SIP1:
** Display Name: ...
** Username: 49#VORWAHLOHNE0#NUMMER#
** Telephone Number: 0#VORWAHLOHNE0#NUMMER#
* Auth:
** Auth Username: 49#VORWAHLOHNE0#NUMMER#
** Password: *********
* Server:
** sip.1und1.de:5060
* Proxy:
** sip.1und1.de:5060
* RTP:
** 30000 und 30019
* STUN:
** stun.1und1.de
* STUN Server Port:
** 3478
* SIP2:
** UDP: 5060
** TCP: 5060

=== Einstellung für Vodafone NGN (Arcor NGN) ===

* SIP1:
** Display Name: ...
** Username: VORWAHLUNDRUFNUMMER
** Telephone Number: (leer lassen)
* Auth:
** Auth Username: VORWAHLUNDRUFNUMMER
** Password: *********
* Server:
** arcor.de:5060
* Proxy:
** VORWAHL.sip.arcor.de:5060
* RTP:
** 10000 und 10001
* STUN:
** (X) use rport
* SIP2:
** UDP: 5060
** TCP: 5060
(getestet von Micha mit EasyBox 802; an EasyBox n-WLAN ausschalten)

=== Einstellung für Sipgate ===

*SIP1
**Display Name: Sipgate Username
**User Name: your SIPgate-ID
**Telephone Number: Sipgate-Telefonnummer
*Auth
**Authentification UserName: your SIPgate-ID
**Password: Sipgate Passwort
*Server
**SIP register address:port: sipgate.de:5060
*Proxy
**SIP proxy1 address:port: sipgate.de:5060
*RTP Audio Channel
**RTP: 22800
**RTCP: 22801
*RTP Video Channel
**RTP: 22804
**RTCP: 22805
*STUN: [X] use rport
*SIP2
**SIP Port Listen
**for UDP: 5062
**for TCP: 5062
**for TCP TLS: 5053

SIP Outbound muss leer sein.

=== Alternative Einstellung für Sipgate ===

Hinter meiner Freetzbox hat die obige Einstellung nix gebracht - incoming calls wurden nicht signalisiert. Folgendes tut dagegen:

*SIP1
**Display Name: Sipgate Username
**User Name: your SIPgate-ID
**Telephone Number: Sipgate-Telefonnummer
*Auth
**Authentification UserName: your SIPgate-ID
**Password: Sipgate Passwort
*Server
**SIP register address:port: sipgate.de:5060
*Proxy
** leer
*SIP2
**Symmetric Mode [X]
**SIP Port Listen
**for UDP: 5062
**for TCP: 5062
**for TCP TLS: 5053
*STUN: [x] use rport

SIP Outbound muss leer sein.

Ein Videotelefonat von Sipgate zu Sipgate zwischen zwei VP6500 wurde erfolgreich getestet. Gegebenenfalls muss die eigene Videoübertragung noch durch Drücken der Taste '''Video''' gestartet werden.

Bei mir hat es nur per UDP funktioniert, aber mit starken Delays (>1s)

=== Einstellung für Ekiga.net ===

*SIP1
**Display Name: Irgendwas
**User Name: username
**Telephone Number: leer
*Auth
**Authentication User Name: username
**Password: password
*Server
**SIP register: ekiga.net:5060
**Protocol: ( ) TCP (*) UDP
**Expire Timer: 3600
**Keep Alive: 0
*Proxy
**alle leer
*STUN
**( ) use rport
**STUN Server IP address: stun.ekiga.net
**STUN Server port: 3478
*SIP2
**(*) Symmetric Mode
**UDP: 5060
**TCP: 5060
**TCP TLS: 5061
*OBproxy
**alle leer

Nach der (kostenlosen) Registrierung bei ekiga.net und der Anmeldung des Telefons kann man unter der 500 einen Audio und Video(!) Test machen. 
Weitere features: https://www.ekiga.net/index.php?page=services 
Ekiga teilt keine Festnetz Rufnummern zu, daher ist ein Anruf von/zu Festnetz Telefonen nicht möglich. 
Bei Ekiga.net angemeldete Geräte können aber problemlos untereinander telefonieren, sogar mit Video. Da man vom Mainscreen des VP5500/6500 aus direkt nur numerische Kontakte (herkömmliche Telefonnumern) wählen kann, Ekiga.net Telefonnummern aber aus [Benutzername]@ekiga.net bestehen, legt man über das Menü des VP5500/6500 einfach einen neuen Kontakt (Telefonbuch) an. Als Video-Rufnummer trägt man einfach [Benutzername]@ekiga.net ein, wobei [Benutzername] der Name des Ekiga-Accounts ist, den man erreichen will. Zwischen der Eingabe von Buchstaben, Zahlen und Sonderzeichen kann man dabei mit der [#]-Taste des VP5500/6500 umschalten.
Sollte bei einem Telefonat über Ekiga Video einmal nicht funktionieren, hilft eventuell die manuelle Aktivierung der Videofunktion mittels der Video-Taste auf der Tastatur des VP6500

=== Einstellung für Fritzbox 7170/7270 und andere mit SIP-Registrar ===
Die Anmeldung eines Telefons auf der Fritzbox starten (System/Ansicht/"Expertenansicht aktivieren", dann Telefonie/Telefoniegeräte/"Neues Gerät einrichten", "Telefon", "Bitte auswählen"/"LAN/WLAN (IP-Telefon)") und sich eine Nummer geben lassen, dann in Registration auf dem VPx500 wechseln und die Einstellungen wie unten vornehmen. Anschließend will das Telefon diese Einstellungen aktivieren, vorher noch auf der FB die Anmeldung starten. 
 
Im Beispiel will die FB die Nummer 621 vergeben: 
'''Reiter SIP1''' 
Display Name: egal <leer lassen> 
User Name: 621 
Telephone Number: 621 
 
'''Reiter Auth''' 
Authentication UserName: 621 
Password: [hier das gleiche, wie auf der FB eingeben] 
 
'''Reiter Server''' 
SIP register address:port 
192.168.2.1:5060 (IP Bitte auf Euer Netz anpassen) oder alternativ: fritz.box:5060 
Protocol: UDP 
ExpireTime: 3600 
Keep Alive: 300 
 
'''Reiter SIP2''' 
[ ] Symmetric Mode 
SIP Port Listen 
for UDP: 5060 
 
'''Anmerkungen dazu:''' 
Protokoll: UDP 
Bei TCP hat das VP6500 nach Minuten oder Stunden immer wieder die Verbindung zur FB verloren. 
Keep Alive: 300 
Die Keep Alive Time habe ich eingestellt, weil ich die TCP Probleme umgehen wollte. Ich denke nicht, dass es zu Problemen bzgl. Akku kommt. Da es so aber perfekt funktioniert, habe ich es gelassen. Das UDP Protokoll kommt zudem mit weniger Netzwerk-Traffic aus. 
Anmeldung: 
Die Anmeldung wurde von der Fritz!Box nicht immer erfolgreich bestätigt. Einfach Weiter klicken und die restlichen Einstellungen vornehmen. Spätestens nach einem Reboot des VPx500 funktioniert alles einwandfrei. 

Falls eure Fritz!Box keine Möglichkeit bietet, ein IP-Telefon anzumelden, empfehle ich euch mal in das http://wiki.ip-phone-forum.de/skript:speedport2fritz einzulesen. 
Bzw. mal im IP-Phone-Forum nach SIP-Registrar suchen. 

Der SIP Listen Port 5060 hat mich viel Zeit gekostet - stand noch von sipgate direkt auf 5062 und das VP5500 hat sich dann zwar an der fritzbox registriert aber keine eingehenden Anrufe empfangen...

=== Fritz!Box Hinweis ===
Hinter meiner Fritz!Box konnte ich auf dem Port 5060 keine Incoming Calls bekommen, da die Box auf diesen Port für ihre eigenes System hört.
Geholfen hat mit dann ein Wechsel auf Port 5061 im Reiter SIP2

== Eigener VoIP Server mit Asterisk ==

*http://www.das-asterisk-buch.de

===Asterisk auf einer Fritz!Box===

*http://www.asterisk-kompakt.de/artikel/45-asterisk-auf-fritzbox-phone.html

== Videogespräche zu anderen Clients / Softphones ==
=== Ekiga Softphone ===

Damit Videos klappen, müssen Ekiga und VP6500 über mindestens einen übereinstimmenden Videocodec verfügen, klar. Im Falle des VP6500 ist es wohl so, daß ausschließlich H.263 in verschiedenen Ausprägungen zur Verfügung steht.

Ekiga kommt jedoch zunächst unter Ubuntu 9.10 nur mit H.261 und Theora Codec. Wir müssen daher den H.263-Codec in Ekiga zusätzlich einhängen.

Leider ist der H.263-Codec nicht ganz frei zugänglich, sodaß wir eine Fremdquelle benötigen, um den Codec mit dem Paketmanager installieren zu können. Daher muß Bojos Ekiga-Plugin-PPA wie in

https://launchpad.net/~bojo42/+archive/ekiga

beschrieben als Paketquelle hinzugefügt werden. Den zugehörigen Schlüssel nicht vergessen!
Wenn die neue Quelle bekannt gemacht ist, können im Paketmanager nun die

; Pakete
: libopal3.6.1-plugins-h263-1998
: libopal3.6.1-plugins-ilbc
: libavcodec-dev

installiert werden. Darauf achten, daß alle Abhängigkeiten sauber erfüllt sind.
Das H.263-Plugin läßt sich nur installieren, wenn libstdc++6 >= 4.4.0 vorhanden ist, was meines Wissens erst ab Ubuntu 9.10 der Fall ist.
Nach der Installation dieser Komponenten kann Ekiga neu gestartet werden. Es sollte nun unter Bearbeiten->Einstellungen->Video->Codecs zusätzlich den H.263-Codec anbieten. Durch Verschieben nach oben kann man diesen beim Handshake priorisieren.
Nach Integration des H.263-Codecs in Ekiga konnte ich mit zwei Sipgate-Accounts störungsfrei, sogar über den gleichen DSL-Anschluß, videofonieren.

== DEMO MODE ==

Um den DEMO MODE zwischen einem VP55 und VP65 herzustellen muss man die Dateien
mit den Einstellungen vom VP55 auf das VP65 übertragen. Diese liegen in
/usr/local/data/demo/ und es sind vier Dateien. Danach ist die SSID und der KEY
bei beiden gleich eingerichtet und die beiden Geräte verbinden sich miteinander.

= Software =

== Vorsicht Fallen! ==
Es ist nicht schwer, sich den Zugang zum Telefon abzuschneiden, wenn man nicht aufpasst.

== Betrieb mit aktivierter serieller Schnittstelle ==

Das 5500 und das 6500 scheint nicht komplett zu starten wenn man TIN auf low hat
und die serielle Schnittstelle benutzt. Man kann das Gerät dann nicht normal bedienen. Dies lässt sich ändern indem man in der Datei

/usr/local/startup/daemon.sh

ziemlich am Anfang das TINDETECT="TRUE" ändert auf TINDETECT="FALSE"

Danach startet er auch mit aktiver serieller Verbindung komplett durch
und das Gerät ist ganz normal bedienbar.

== Grundlagen ==
Bestimmte Aktionen werden immer wieder benötigt.
Diese sollen hier kurz beschrieben werden.

Es werden dennoch grundlegende Kenntnisse von Kommandozeilen vorausgesetzt.

==== Dateien bearbeiten mit vi ====
Auf dem Telefon ist der minimalistische Editor vi installiert mit dem Dateien über Telnet bearbeitet werden können.
Für eine genaue Bedienung bitte Google benutzen.
Die wichtigsten Bedienelemente werden hier kurz erläutert.

Datei Öffnen mit 'vi Dateipfad'
vi kennt zwei Modi: Kommando- und Einfüge-Modus.

'''i''' - wechselt in den Einfüge-Modus, in dem geschrieben werden kann 
'''a''' - anhängen (hinter dem aktuellem Zeichen in den Einfüge-Modus) 
'''[Esc]''' wechselt zurück in den Kommandomodus.
In diesem kann mittels Pfeil- und Bildlauftasten navigiert werden.
:x - löscht das Zeichen an Cursor position
:d''n''d - löscht ''n'' Zeile(n) in den Zeilenbuffer (ohne ''n'' = eine Zeile)
:y''n''y - kopiert ''n'' Zeile(n) in den Zeilenbuffer (ohne ''n'' = eine Zeile)
:p - fügt Inhalt des Zeilenbuffer '''unter''' der aktuellen Zeile ein
:<nowiki>:</nowiki>q! - schließt ohne zu speichern
:<nowiki>:</nowiki>w - speichert
:<nowiki>:</nowiki>wq - speichert und beenden

==== Dateien auf das Telefon laden ====
Um Daten von einem http-Server zu laden, benutzt man
wget url
Die Datei wird dann in das aktuelle Verzeichnis geladen, weswegen vorher in das Zielverzeichnis wechseln.

Um Daten von einem ftp-Server zu laden, benutzt man ftp.
Auch hier muss vorher in das zielverzeichnis gewechselt werden.
ftp hostname
dann gegebenenfalls die Zugangsdaten eingeben und mittels 'cd' und 'ls' in das Entsprechende Verzeichnis auf dem FTP-Server wechseln
und anschließend mittels
get dateiname
die Datei herunterladen.
==== Dateien vom Telefon herunterladen ====
Auch hier bietet sich ein FTP an.
Mittels 'ftp hostname' verbinden, Benutzerdaten eingeben, in das entsprechende FTP-Server-Verzeischnis wechseln und mittels
put localeDatei
eine Lokale Datei hochladen.

==== Alternative: Dropbear ====

Wurde der dropbear-ssh server installiert [[#Dropbear (SSH-Server) installieren]] können mittels eines Programms mit SCP-Unterstützung (zB. [http://winscp.net/eng/docs/lang:de WinSCP] für Windows) sehr komfortabel Dateien ausgetauscht werden.

Mit WinSCP können auch Dateien direkt bearbeitet werden.
Der Client lädt die Datei herunter, öffnet einen Editor und lädt die Datei wieder herauf, wenn diese geändert wurde.

== Grundkonfiguration, die das Leben erleichtert ==
=== .bashrc ===
Die installierte Shell ist die bash. Einstellungen bezieht sie aus der (versteckten) Datei ".bashrc". Hier kann man sinnvolle Ergänzungen vornehmen, damit sich das Telefon ein bißchen mehr wie ein gewohntes Linux-System verhält:

<syntaxhighlight lang="c">
alias vim=vi
PS1="[\u@\h] \w $ "
</syntaxhighlight>

== Backup ==
=== Backup des Flash ===
If you want to make a backup of your root partition, you can do as
follows:

<syntaxhighlight lang="c">
echo '#!/bin/sh' > /tmp/backup.sh
echo 'cat /dev/mtdb2 2>/dev/null' >> /tmp/backup.sh
chmod 700 /tmp/backup.sh
micro_inetd 31337 /tmp/backup.sh
</syntaxhighlight>

This'll make your device listen for incoming connections on port 31337.
On your host system you may then simply run
nc ip.of.your.phone 31337 > fon_rootfs
et voilà, you got your rootfs packed into a file.

Note that the backed up file is not ext2, but a jffs2 formatted
filesystem. These can't be handled by a simple "mount -o loop" as you'd
have thought... so here's how you mount it:

<syntaxhighlight lang="c">
modprobe jffs2
modprobe mtdram total_size=65536 erase_size=128
modprobe mtdblock
mkdir /tmp/phone-root
mknod /tmp/phone-mtdb2 b 31 0
dd if=/your/backup/file of=/tmp/phone-mtdb2
mount -t jffs2 /tmp/phone-mtdb2 /tmp/phone-root
</syntaxhighlight>

[[#Dateisystem herunterladen]] describes another way to dump the filesystem for closer examination.

=== Komplettes Backup ===
Die Datei http://www.mikrocontroller.net/attachment/73323/S91backup_pipe auf das Gerät laden und als ausführbar markieren.

cd /etc/rc.d/init.d
wget http://www.mikrocontroller.net/attachment/73323/S91backup_pipe
chmod +x /etc/rc.d/init.d/S91backup_pipe

Damit wird eine Art Backup-Server mit dem Boot gestartet.
wenn man dies nicht möchte kann man das Skript natürlich auch an jeden beliebigen anderen Ort legen und per Hand starten.

Nun kann man von einem Rechner aus mittels nc (netcat) die Bereiche sichern:

nc 192.168.1.3 31337 > fon_rootfs
nc 192.168.1.3 31338 > fon_udata
nc 192.168.1.3 31339 > fon_usettings
nc 192.168.1.3 31340 > fon_bootld
nc 192.168.1.3 31341 > fon_kernel

Die 192.168.1.3 natürlich mit der IP des Gerätes austauschen, die fon_*
Dateinamen könnt ihr natürlich auch frei vergeben.

fon_udata ist die /user_data Partition, fon_usertings dementsprechend
die /user_settings Partition.

Der bootld Bereich enthält auch die Parameter. Um das später (falls
überhaupt nötig) mittels blob zu restaurieren müsste die Datei noch in
zwei Teile aufgeteilt werden. Der erste enthält dann den reinen
Bootloader-Bereich, der zweite die Parameter. Wer's wirklich braucht für
den kann ich noch ne Anleitung zum Aufteilen geben. Wirklich Sinnvoll
ist das aber nicht, hat man den Bootloader erstmal mit was anderem
überschrieben kann man ihn ja auch nicht mehr zum Wiederherstellen
benutzen....

=== Zurückspielen der Backups ===

1) Man braucht ein (die) Backup-Image(s).

2) Serielle Verbindung zum Telefon

3) Akku abstecken, wieder anstecken.

4) Telefon einschalten und im Terminalprogram auf die Tasten kloppen, so
das man im Bootloader landet. Dabei muss man recht schnell sein. Es
sollte dann ein Prompt kommen:

<syntaxhighlight lang="c">
blob>
</syntaxhighlight>

5) Nun gibt man ein
xdownload param
Wobei 'param' der Teil ist, den man wiederherstellen will:
* blob - Bootloader (fon_bootld)
* param - Parameter Bereich (Bootloader oder Kernel?) (fon_bootld)
* kernel - Der Kernel (fon_kernel)
* ramdisk - Das Root-Filesystem / (fon_rootfs)
* ramdisk2 - Das /user_data Filesystem (fon_udata)
* ramdisk3 - Das /user_settings Filesystem (fon_usettings)

Beim Backup ist blob + param in einer Datei, müsste man also ggf.
erstmal aufsplitten.

6) Er wartet dann auf den Upload. Nun startet man im Terminalprogram den
Upload des Backup-Images, dazu verwendet man das X-Modem Protokoll.

7) Kaffee trinken, auf's Klo gehen, mit Frau/Freundin/Mutter ein Gespräch
anfangen.

8) Irgendwann ist der Upload fertig. Dauert halt lange. Man landet
wieder am "blob>" prompt. Nun gibt man
flash param
ein.

9) Er schreibt nun das, was man hochgeladen hat, in das Flash.

10) "boot" eingeben. Da Telefon bootet nun normal.

Achtung: Wenn im Backup nicht die Änderung gemacht wurde damit das
Telefon auch bei angeschlossener serieller Schnittstelle startet, kommt
man nicht weiter als wie bis zur Sanduhr. Dann einfach die serielle
abstecken (Also den TIN pin wieder freigeben) und das Telefon neustarten
(Akku kurz ab- und wieder anstöpseln)

=== Dateisystem herunterladen ===
Zum unkomplizierten Durchsuchen des Dateisystems kann es nützlich sein, dieses vom Gerät zu kopieren.

Folgende Befehle erzeugen wie beim Backup des Flash einen kleinen Server, dessen Output auf anderer Seite mittels mittels nc abgeholt werden kann:

<syntaxhighlight lang="c">
echo '#! /bin/sh' > /tmp/backup.sh
echo 'cd /' >> /tmp/backup.sh
chmod 700 /tmp/backup.sh
echo 'tar cf - bin boot dev etc home lib mnt opt root sbin tmp trace upgrade user_data user_settings usr var 2>/dev/null' >> /tmp/backup.sh
micro_inetd 31340 /tmp/backup.sh
</syntaxhighlight>

Die lange Liste mit Unterverzeichnissen ist notwendig um /proc zu überspringen, was Probleme mit tar verursachen würde.

Auf einem anderen Linux system (oder cygwin) kann mittels
<syntaxhighlight lang="c">
nc telefon-Ip 31340 > file.tar
</syntaxhighlight>
die Datei abgerufen werden.

Der Vorgang dauert aber ein ganz paar Minuten.

Heraus kommt ein Tar-Archiv, was alle Dateien des Gerätes enthält - inclusive der temporären Dateien der Ram-Disks.

== Erkunden des Systems mit Bordmitteln ==

=== Ausgabe von <tt>dmesg</tt> auf einem VP6500 ===
<pre>
6>NET4: Unix domain sockets 1.0/SMP for Linux NET4.0.
NetWinder Floating Point Emulator V0.95 (c) 1998-1999 Rebel.com
VFS: Mounted root (jffs2 filesystem).
Freeing init memory: 68K
PCB version: ind3 v2
Driver SYSTCLK: SYSTCLK-1.12 (REFERENCED)
Driver GPIO-1.59 (REFERENCED)
****p_gpio_init_low_bat****
GPIO: p_gpio_it_init at 762
Driver FRAMEBUF-1.12 (REFERENCED)
Driver SPI-1.20 (REFERENCED) Debug level 3

u32_spi1_MinLenghtForDMAInTX set to 300

u32_spi1_MinLenghtForDMAInRX set to 300
Driver LCD-1.20 (REFERENCED)
Driver TVLINK-1.45 (REFERENCED)
Reset from Software Reset.
Motorola PostProcessor Linux driver ver 0.64 - Copyright (C) 2003 Motorola Inc
pp: hw ver = 2
prp_dbg=0
Motorola PreProcessor Linux driver ver 0.0 - Copyright (C) 2003 Motorola Inc
hmp4d: base_port=0x10026800 irq=50
hmp4d: module inserted
hmp4e: base_port=0x10026c00 irq=49
hmp4e: Compatble HW found with ID: 0x004c1882
hmp4e: module inserted. Major = 249
SPI2:: drv_Init :PID of driver: 134
SPI2:: drv_Init :ScanList not provided. Will use the default scan list.
SPI2:: drv_Init :ScanChannelList :1 6 11 14 2 7 12 3 8 13 4 9 5 10
SPI2:: drv_Init :setting PhyType to: Rf-to-Rf
SPI2:: drv_Init :Ref.Clock parameter not provided
SPI2:: drv_Init :Configure target for a reference clock of 'default=40' Mhz.
SPI2:: drvRegEtherDev :Interface Name is: eth%d
SPI2:: drv_Init :HEOCSIWPOWON: Powering on...
SPI2:: drvPhase2Init :Protocol Firmware will be loaded by driver ...
SPI2:: drvPhase2Init :Initializing HHAL (PhgHhalInitialize)...
Divider : 8

OCR2 : e4015308 (12582912)
Reset : 3 / 27 (c497cc00 / e401531c)

Reset : 3 / 27 (c497cc00 / e401531c)
GPIO: p_gpio_init_gpio_status at 1262
GPIO: POWER_FAIL signal NOT detected at GPIO driver init carry on !!!
GPIO: CHARGE_IN at init
GPIO: LOW_BAT_OUT at init
GPIO: No accessory plugged at init. - Set Video on jack
GPIO: camera to front at init
**ChargeStatusPmb=========gpio_Read_ChargeStatus_Ready=1
SPI2:: PhgOsal_linux_init_thread :assigning thread name and deamonize() ..
SPI2:: drvPhase2Init :Success
SPI2:: drvPhase2Init : registering callbacks with HHAL..
SPI2:: drvHhalEventIndicationHandler :
SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVNT_INIT_COMPLETE; setting CARRIER_ON
SPI2:: drvPhase2Init :calling PhgHhalQueueMgmtReq()!
PhgHhalQueueMgmtReq:1172:HHAL got Init message
PhgHhalQueueMgmtReq:1217:HHAL done Init message
SPI2:: drvHhalEventIndicationHandler :PS wake (0) in Drvmain
SPI2:: drvHhalEventIndicationHandler :
SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVENT_DISCONNECT; setting CARRIER_OFF
SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00001002, IFF_UP=0
SPI2:: drvHhalEventIndicationHandler :device was already closed
SPI2:: drvMgmtCfmHndler :Using MAC Address: 00:08:c6:86:8b:99
SPI2:: drvPhase2Init :init etherdev; stopping queue, setting CARRIER_OFF
SPI2:: drv_Init :Philips WLAN Drv - loaded - in state: 1
SPI2:: drvInit :Philips WLAN Drv - loaded
SPI2:: drvOpen :opening net device
SPI2:: drvOpen :Device is not associated!
SPI2:: drvOpen :Carrier flag is already set to CARRIER_OFF
SPI2:: drvOpen :Disabling again netqueue
requested reg.domain code setting = 3
SPI2:: drvIoctl :set u8LinkAdaptation : 1 Result=[0]
SPI2:: drvIoctl :changed HEOCSIWLNADPALLOWRATES: 8 allowed rate codes
SPI2:: drvInitConnect :Req to connect to new WLAN network
SPI2:: drvInitConnect :Disabling TX queue and setting CARRIER_OFF
SPI2:: drvInitConnect :Connecting To AP...
SPI2:: drvInitConnect :step2
SPI2:: drvHhalEventIndicationHandler :
SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVENT_DISCONNECT; setting CARRIER_OFF
SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00001003, IFF_UP=1
SPI2:: drvHhalEventIndicationHandler :device was already opened; stopping queue
SPI2:: drvInitConnect :step3 : u8Status 255
SPI2:: drvInitConnect :step5
SPI2:: drvInitConnect :TIMEDOUT
SPI2:: drvInitConnect :step6
SPI2:: drvInitParamsAndPowerOnAndConnect :Connect failed!
Motorola CSI Linux driver ver 0.1
- Copyright (C) 2004 Motorola Inc

Driver SENSOR-1.29 (REFERENCED)
i2c-client version : 1.9
Initialize i2c-client-aic14 module
Module i2c-client-aic14 initialized
Insert module aic14 (AIC14-1.0)
Module AIC14 assumes CODEC MCLK already configured for 20480000Hz
Driver KPP-1.36 (REFERENCED)
Driver DOZE-1.27 (REFERENCED)
SPI2:: drvDoScan :Buero (bittorf)
SPI2:: drvProcessScanCfm :Scan Confirm: Success 1 APs
SPI2:: drvInitConnect :Req to connect to new WLAN network
SPI2:: drvInitConnect :Disabling TX queue and setting CARRIER_OFF
SPI2:: drvInitConnect :Connecting To AP...
SPI2:: drvInitConnect :step2
SPI2:: drvHhalEventIndicationHandler :
SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVNT_INIT_CONNECT; setting CARRIER_ON
SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00001003, IFF_UP=1
SPI2:: drvHhalEventIndicationHandler :device was already opened; enabling queue
SPI2:: drvInitConnect :step3 : u8Status 8
SPI2:: drvInitConnect :step4
SPI2:: drvInitConnect :Successful
SPI2:: drvInitConnect :step6
SPI2:: drvIoctl :dot11LongRetryLimitAC0 = 8
SPI2:: drvIoctl :dot11LongRetryLimitAC1 = 8
SPI2:: drvIoctl :dot11LongRetryLimitAC2 = 8
SPI2:: drvIoctl :dot11LongRetryLimitAC3 = 8
SPI2:: drvIoctl :dot11ShortRetryLimitAC0 = 8
SPI2:: drvIoctl :dot11ShortRetryLimitAC1 = 8
SPI2:: drvIoctl :dot11ShortRetryLimitAC2 = 8
SPI2:: drvIoctl :dot11ShortRetryLimitAC3 = 8
SPI2:: drvIoctl :PA Request
SPI2:: drvIoctl :No state change!
SPI2:: drvIoctl :Fast PS Request
PhgHhalDoM2SDMA:1661:-->P1
SPI2:: drvHhalEventIndicationHandler :PS Ind (1) in Drvmain
SPI2:: drvStop :Driver Stop: disable TX queue! (usage: 2)
SPI2:: drvIoctl :Deauth BSSID: 00:1d:7e:18:e3:89
SPI2:: drvHhalEventIndicationHandler :
SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVENT_DISCONNECT; setting CARRIER_OFF
SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00000002, IFF_UP=0
SPI2:: drvHhalEventIndicationHandler :device was already closed
SPI2:: drvOpen :opening net device
SPI2:: drvOpen :ERROR: Associated, but Carrier flag is set to CARRIER_OFF
SPI2:: drvDoScan :Buero (bittorf)
SPI2:: drvProcessScanCfm :Scan Confirm: Success 1 APs
SPI2:: drvInitConnect :Req to connect to new WLAN network
SPI2:: drvInitConnect :Disabling TX queue and setting CARRIER_OFF
SPI2:: drvInitConnect :Connecting To AP...
SPI2:: drvInitConnect :step2
SPI2:: drvHhalEventIndicationHandler :
SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVNT_INIT_CONNECT; setting CARRIER_ON
SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00000003, IFF_UP=1
SPI2:: drvHhalEventIndicationHandler :device was already opened; enabling queue
SPI2:: drvInitConnect :step3 : u8Status 8
SPI2:: drvInitConnect :step4
SPI2:: drvInitConnect :Successful
SPI2:: drvInitConnect :step6
SPI2:: drvHhalEventIndicationHandler :PS Ind (1) in Drvmain
SPI2:: drvIoctl :PA Request
PhgHhalDoM2SDMA:1661:-->P0
SPI2:: drvHhalEventIndicationHandler :PS wake (0) in Drvmain
drvSetWOWFilter: Enable UNICAST: Disable ARP: Enable
Ip addr = 10.63.17.5. LMP=2
SPI2:: drvIoctl :PA Request
SPI2:: drvIoctl :No state change!
SPI2:: drvIoctl :Fast PS Request
PhgHhalDoM2SDMA:1661:-->P1
SPI2:: drvHhalEventIndicationHandler :PS Ind (1) in Drvmain
Sensor driver: initialize device OV7660
Warning: Remapping obsolete /dev/fb* minor 32 to 1
SPI2:: drvIoctl :dot11LongRetryLimitAC0 = 4
SPI2:: drvIoctl :dot11LongRetryLimitAC1 = 4
SPI2:: drvIoctl :dot11LongRetryLimitAC2 = 4
SPI2:: drvIoctl :dot11LongRetryLimitAC3 = 4
SPI2:: drvIoctl :dot11ShortRetryLimitAC0 = 4
SPI2:: drvIoctl :dot11ShortRetryLimitAC1 = 4
SPI2:: drvIoctl :dot11ShortRetryLimitAC2 = 4
SPI2:: drvIoctl :dot11ShortRetryLimitAC3 = 4
SPI2:: drvIoctl :PA Request
PhgHhalDoM2SDMA:1661:-->P0
SPI2:: drvHhalEventIndicationHandler :PS wake (0) in Drvmain
</pre>

=== Ausgabe von <tt>logread</tt> auf einem VP6500 ===
<pre>
Jan 1 00:00:00 imx21 syslog.info syslogd started: BusyBox v0.60.0 (2007.02.28-13:39+0000)
Jan 1 00:00:02 imx21 daemon.emerg klogd: klogd started: BusyBox v0.60.0 (2007.02.28-13:39+0000)
Jan 1 00:00:02 imx21 daemon.warn klogd: Linux version 2.4.20-celf3 (root@wbul04) (gcc version 3.3.2) #1 Wed Feb 28 13:30:26 UTC 2007
Jan 1 00:00:02 imx21 daemon.warn klogd: CPU: ARM926EJ-Sid(wb) [41069264] revision 4 (ARMv?(8))
Jan 1 00:00:02 imx21 daemon.warn klogd: CPU: D undefined 14 cache
Jan 1 00:00:02 imx21 daemon.warn klogd: CPU: I cache: 16384 bytes, associativity 4, 32 byte lines, 128 sets
Jan 1 00:00:02 imx21 daemon.warn klogd: CPU: D cache: 16384 bytes, associativity 4, 32 byte lines, 128 sets
Jan 1 00:00:02 imx21 daemon.warn klogd: Machine: Freescale i.MX2 ADS
Jan 1 00:00:02 imx21 daemon.warn klogd: FCLK=266000 kHz HCLK=133000 kHz IPGCLK=66500 kHz
Jan 1 00:00:02 imx21 daemon.warn klogd: PERCLKs: 1=44333 KHz 2=33250 kHz 3=44333 kHz 4=88666 kHz
Jan 1 00:00:02 imx21 daemon.warn klogd: On node 0 totalpages: 16384
Jan 1 00:00:02 imx21 daemon.warn klogd: zone(0): 16384 pages.
Jan 1 00:00:02 imx21 daemon.warn klogd: zone(1): 0 pages.
Jan 1 00:00:02 imx21 daemon.warn klogd: zone(2): 0 pages.
Jan 1 00:00:02 imx21 daemon.warn klogd: Kernel command line: root=/dev/mtdblock2 noinitrd ip=none mtdparts=s29gl512n:256k@0x00000000
(bootloader)ro,896k@0x00040000(kernel)ro,50432k@0x00120000(fs#1),12800k@0x03260000(fs#2),1152k@0x03EE0000(fs#3)
Jan 1 00:00:02 imx21 daemon.debug klogd: Relocating machine vectors to 0xffff0000
Jan 1 00:00:02 imx21 daemon.warn klogd: Console: colour dummy device 80x30
Jan 1 00:00:02 imx21 daemon.warn klogd: Calibrating delay loop (skipped)... 132.71 BogoMIPS
Jan 1 00:00:02 imx21 daemon.info klogd: Memory: 64MB = 64MB total
Jan 1 00:00:02 imx21 daemon.notice klogd: Memory: 63052KB available (1366K code, 299K data, 68K init)
Jan 1 00:00:02 imx21 daemon.info klogd: Dentry cache hash table entries: 8192 (order: 4, 65536 bytes)
Jan 1 00:00:02 imx21 daemon.info klogd: Inode cache hash table entries: 4096 (order: 3, 32768 bytes)
Jan 1 00:00:02 imx21 daemon.warn klogd: Mount-cache hash table entries: 1024 (order: 1, 8192 bytes)
Jan 1 00:00:02 imx21 daemon.warn klogd: Buffer-cache hash table entries: 4096 (order: 2, 16384 bytes)
Jan 1 00:00:02 imx21 daemon.warn klogd: Page-cache hash table entries: 16384 (order: 4, 65536 bytes)
Jan 1 00:00:02 imx21 daemon.warn klogd: POSIX conformance testing by UNIFIX
Jan 1 00:00:02 imx21 daemon.info klogd: Linux NET4.0 for Linux 2.4
Jan 1 00:00:02 imx21 daemon.info klogd: Based upon Swansea University Computer Society NET3.039
Jan 1 00:00:02 imx21 daemon.warn klogd: Initializing RT netlink socket
Jan 1 00:00:02 imx21 daemon.info klogd: apm: Simulating APM BIOS version 1.2 (Driver version 1.0)
Jan 1 00:00:02 imx21 daemon.warn klogd: i.MX21 Dynamic Power Management
Jan 1 00:00:02 imx21 daemon.warn klogd: Starting kswapd
Jan 1 00:00:02 imx21 daemon.warn klogd: Disabling the Out Of Memory Killer
Jan 1 00:00:02 imx21 daemon.notice klogd: JFFS2 version 2.1. (C) 2001, 2002 Red Hat, Inc., designed by Axis Communications AB.
Jan 1 00:00:02 imx21 daemon.info klogd: i2c-core.o: i2c core module version 2.6.2 (20011118)
Jan 1 00:00:02 imx21 daemon.warn klogd: pty: 256 Unix98 ptys configured
Jan 1 00:00:02 imx21 daemon.info klogd: Serial driver version 5.05c (2001-07-08) with no serial options enabled
Jan 1 00:00:02 imx21 daemon.warn klogd: UART driver version 0.3.6
Jan 1 00:00:02 imx21 daemon.warn klogd: RAMDISK driver initialized: 16 RAM disks of 4096K size 1024 blocksize
Jan 1 00:00:02 imx21 daemon.warn klogd: I2C driver Feb 28 2007 / 13:31:04
Jan 1 00:00:02 imx21 daemon.info klogd: Initialize i2c-client-dbmx-codec module
Jan 1 00:00:02 imx21 daemon.notice klogd: s29gl512n: probing 16-bit flash bus
Jan 1 00:00:02 imx21 daemon.notice klogd: Amd/Fujitsu Extended Query Table v1.3 at 0x0040
Jan 1 00:00:02 imx21 daemon.notice klogd: number of CFI chips: 1
Jan 1 00:00:02 imx21 daemon.notice klogd: cfi_cmdset_0002: Using Write Buffer method.
Jan 1 00:00:02 imx21 daemon.notice klogd: cfi_cmdset_0002: buffer_Write_Time = 128
Jan 1 00:00:02 imx21 daemon.notice klogd: cfi_cmdset_0002: Disabling fast programming due to code brokenness.
Jan 1 00:00:02 imx21 daemon.notice klogd: Using static partition definition
Jan 1 00:00:02 imx21 daemon.notice klogd: Creating 5 MTD partitions on "s29gl512n":
Jan 1 00:00:02 imx21 daemon.notice klogd: 0x00000000-0x00040000 : "bootloader"
Jan 1 00:00:02 imx21 daemon.notice klogd: 0x00040000-0x00120000 : "kernel"
Jan 1 00:00:02 imx21 daemon.notice klogd: 0x00120000-0x03260000 : "fs #1"
Jan 1 00:00:02 imx21 daemon.notice klogd: 0x03260000-0x03ee0000 : "fs #2"
Jan 1 00:00:02 imx21 daemon.notice klogd: 0x03ee0000-0x04000000 : "fs #3"
Jan 1 00:00:02 imx21 daemon.info klogd: NET4: Linux TCP/IP 1.0 for NET4.0
Jan 1 00:00:02 imx21 daemon.info klogd: IP Protocols: ICMP, UDP, TCP
Jan 1 00:00:02 imx21 daemon.info klogd: IP: routing cache hash table of 512 buckets, 4Kbytes
Jan 1 00:00:02 imx21 daemon.info klogd: TCP: Hash tables configured (established 4096 bind 8192)
Jan 1 00:00:02 imx21 daemon.info klogd: NET4: Unix domain sockets 1.0/SMP for Linux NET4.0.
Jan 1 00:00:02 imx21 daemon.warn klogd: NetWinder Floating Point Emulator V0.95 (c) 1998-1999 Rebel.com
Jan 1 00:00:02 imx21 daemon.warn klogd: VFS: Mounted root (jffs2 filesystem).
Jan 1 00:00:02 imx21 daemon.info klogd: Freeing init memory: 68K
Jan 1 00:00:02 imx21 daemon.warn klogd: PCB version: ind3 v2
Jan 1 00:00:02 imx21 daemon.info klogd: Driver SYSTCLK: SYSTCLK-1.12 (REFERENCED)
Jan 1 00:00:02 imx21 daemon.info klogd: Driver GPIO-1.59 (REFERENCED)
Jan 1 00:00:02 imx21 daemon.warn klogd: ****p_gpio_init_low_bat****
Jan 1 00:00:02 imx21 daemon.warn klogd: GPIO: p_gpio_it_init at 762
Jan 1 00:00:02 imx21 daemon.info klogd: Driver FRAMEBUF-1.12 (REFERENCED)
Jan 1 00:00:02 imx21 daemon.info klogd: Driver SPI-1.20 (REFERENCED) Debug level 3
Jan 1 00:00:02 imx21 daemon.warn klogd:
Jan 1 00:00:02 imx21 daemon.warn klogd: u32_spi1_MinLenghtForDMAInTX set to 300
Jan 1 00:00:02 imx21 daemon.warn klogd:
Jan 1 00:00:02 imx21 daemon.warn klogd: u32_spi1_MinLenghtForDMAInRX set to 300
Jan 1 00:00:02 imx21 daemon.info klogd: Driver LCD-1.20 (REFERENCED)
Jan 1 00:00:02 imx21 daemon.info klogd: Driver TVLINK-1.45 (REFERENCED)
Jan 1 00:00:02 imx21 daemon.warn klogd: Reset from Software Reset.
Jan 1 00:00:02 imx21 daemon.warn klogd: Motorola PostProcessor Linux driver ver 0.64 - Copyright (C) 2003 Motorola Inc
Jan 1 00:00:02 imx21 daemon.warn klogd: pp: hw ver = 2
Jan 1 00:00:03 imx21 daemon.warn klogd: prp_dbg=0
Jan 1 00:00:03 imx21 daemon.warn klogd: Motorola PreProcessor Linux driver ver 0.0 - Copyright (C) 2003 Motorola Inc
Jan 1 00:00:03 imx21 daemon.info klogd: hmp4d: base_port=0x10026800 irq=50
Jan 1 00:00:03 imx21 daemon.info klogd: hmp4d: module inserted
Jan 1 00:00:03 imx21 daemon.info klogd: hmp4e: base_port=0x10026c00 irq=49
Jan 1 00:00:03 imx21 daemon.info klogd: hmp4e: Compatble HW found with ID: 0x004c1882
Jan 1 00:00:03 imx21 daemon.info klogd: hmp4e: module inserted. Major = 249
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drv_Init :PID of driver: 134
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drv_Init :ScanList not provided. Will use the default scan list.
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drv_Init :ScanChannelList :1 6 11 14 2 7 12 3 8 13 4 9 5 10
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drv_Init :setting PhyType to: Rf-to-Rf
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drv_Init :Ref.Clock parameter not provided
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drv_Init :Configure target for a reference clock of 'default=40' Mhz.
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drvRegEtherDev :Interface Name is: eth%d
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drv_Init :HEOCSIWPOWON: Powering on...
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drvPhase2Init :Protocol Firmware will be loaded by driver ...
Jan 1 00:00:03 imx21 daemon.err klogd: SPI2:: drvPhase2Init :Initializing HHAL (PhgHhalInitialize)...
Jan 1 00:00:03 imx21 daemon.warn klogd: Divider : 8
Jan 1 00:00:03 imx21 daemon.warn klogd:
Jan 1 00:00:03 imx21 daemon.warn klogd: OCR2 : e4015308 (12582912)
Jan 1 00:00:03 imx21 daemon.warn klogd: Reset : 3 / 27 (c497cc00 / e401531c)
Jan 1 00:00:03 imx21 daemon.warn klogd:
Jan 1 00:00:03 imx21 daemon.warn klogd: Reset : 3 / 27 (c497cc00 / e401531c)
Jan 1 00:00:03 imx21 daemon.warn klogd: GPIO: p_gpio_init_gpio_status at 1262
Jan 1 00:00:03 imx21 daemon.warn klogd: GPIO: POWER_FAIL signal NOT detected at GPIO driver init carry on !!!
Jan 1 00:00:03 imx21 daemon.warn klogd: GPIO: CHARGE_IN at init
Jan 1 00:00:03 imx21 daemon.warn klogd: GPIO: LOW_BAT_OUT at init
Jan 1 00:00:03 imx21 daemon.warn klogd: GPIO: No accessory plugged at init. - Set Video on jack
Jan 1 00:00:03 imx21 daemon.warn klogd: GPIO: camera to front at init
Jan 1 00:00:04 imx21 daemon.warn klogd: **ChargeStatusPmb=========gpio_Read_ChargeStatus_Ready=1
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: PhgOsal_linux_init_thread :assigning thread name and deamonize() ..
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvPhase2Init :Success
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvPhase2Init : registering callbacks with HHAL..
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVNT_INIT_COMPLETE; setting CARRIER_ON
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvPhase2Init :calling PhgHhalQueueMgmtReq()!
Jan 1 00:00:06 imx21 daemon.info klogd: PhgHhalQueueMgmtReq:1172:HHAL got Init message
Jan 1 00:00:06 imx21 daemon.info klogd: PhgHhalQueueMgmtReq:1217:HHAL done Init message
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PS wake (0) in Drvmain
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVENT_DISCONNECT; setting CARRIER_OFF
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00001002, IFF_UP=0
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :device was already closed
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvMgmtCfmHndler :Using MAC Address: 00:08:c6:86:8b:99
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvPhase2Init :init etherdev; stopping queue, setting CARRIER_OFF
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drv_Init :Philips WLAN Drv - loaded - in state: 1
Jan 1 00:00:06 imx21 daemon.err klogd: SPI2:: drvInit :Philips WLAN Drv - loaded
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvOpen :opening net device
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvOpen :Device is not associated!
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvOpen :Carrier flag is already set to CARRIER_OFF
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvOpen :Disabling again netqueue
Jan 1 00:00:07 imx21 daemon.warn klogd: requested reg.domain code setting = 3
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvIoctl :set u8LinkAdaptation : 1 Result=[0]
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvIoctl :changed HEOCSIWLNADPALLOWRATES: 8 allowed rate codes
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvInitConnect :Req to connect to new WLAN network
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvInitConnect :Disabling TX queue and setting CARRIER_OFF
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvInitConnect :Connecting To AP...
Jan 1 00:00:07 imx21 daemon.err klogd: SPI2:: drvInitConnect :step2
Jan 1 00:00:10 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :
Jan 1 00:00:10 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVENT_DISCONNECT; setting CARRIER_OFF
Jan 1 00:00:10 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00001003, IFF_UP=1
Jan 1 00:00:10 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :device was already opened; stopping queue
Jan 1 00:00:11 imx21 daemon.err klogd: SPI2:: drvInitConnect :step3 : u8Status 255
Jan 1 00:00:11 imx21 daemon.err klogd: SPI2:: drvInitConnect :step5
Jan 1 00:00:11 imx21 daemon.err klogd: SPI2:: drvInitConnect :TIMEDOUT
Jan 1 00:00:11 imx21 daemon.err klogd: SPI2:: drvInitConnect :step6
Jan 1 00:00:11 imx21 daemon.err klogd: SPI2:: drvInitParamsAndPowerOnAndConnect :Connect failed!
Jan 1 00:00:12 imx21 daemon.warn klogd: Motorola CSI Linux driver ver 0.1
Jan 1 00:00:12 imx21 daemon.warn klogd: - Copyright (C) 2004 Motorola Inc
Jan 1 00:00:12 imx21 daemon.warn klogd:
Jan 1 00:00:12 imx21 daemon.info klogd: Driver SENSOR-1.29 (REFERENCED)
Jan 1 00:00:12 imx21 daemon.info klogd: i2c-client version : 1.9
Jan 1 00:00:12 imx21 daemon.info klogd: Initialize i2c-client-aic14 module
Jan 1 00:00:12 imx21 daemon.info klogd: Module i2c-client-aic14 initialized
Jan 1 00:00:12 imx21 daemon.alert klogd: Insert module aic14 (AIC14-1.0)
Jan 1 00:00:12 imx21 daemon.warn klogd: Module AIC14 assumes CODEC MCLK already configured for 20480000Hz
Jan 1 00:00:12 imx21 daemon.info klogd: Driver KPP-1.36 (REFERENCED)
Jan 1 00:00:13 imx21 daemon.info klogd: Driver DOZE-1.27 (REFERENCED)
Jan 1 00:00:14 imx21 daemon.err klogd: SPI2:: drvDoScan :Buero (bittorf)
Jan 1 00:00:15 imx21 daemon.err klogd: SPI2:: drvProcessScanCfm :Scan Confirm: Success 1 APs
Jan 1 00:00:15 imx21 daemon.info netsyncd[315]: creating FIFO_NETSYNC_HMON_NAME...
Jan 1 00:00:15 imx21 daemon.info netsyncd[315]: creating FIFO_HMON_NETSYNC_NAME...
Jan 1 00:00:18 imx21 daemon.err klogd: SPI2:: drvInitConnect :Req to connect to new WLAN network
Jan 1 00:00:18 imx21 daemon.err klogd: SPI2:: drvInitConnect :Disabling TX queue and setting CARRIER_OFF
Jan 1 00:00:18 imx21 daemon.err klogd: SPI2:: drvInitConnect :Connecting To AP...
Jan 1 00:00:18 imx21 daemon.err klogd: SPI2:: drvInitConnect :step2
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVNT_INIT_CONNECT; setting CARRIER_ON
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00001003, IFF_UP=1
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :device was already opened; enabling queue
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvInitConnect :step3 : u8Status 8
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvInitConnect :step4
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvInitConnect :Successful
Jan 1 00:00:19 imx21 daemon.err klogd: SPI2:: drvInitConnect :step6
Jan 1 00:00:19 imx21 daemon.err modprobe: modprobe: Can't locate module sound-slot-0
Jan 1 00:00:19 imx21 daemon.err modprobe: modprobe: Can't locate module sound-service-0-0
Jan 1 00:00:20 imx21 local0.debug dhcpcd[337]: broadcasting DHCP_DISCOVER
Jan 1 00:00:23 imx21 local0.debug dhcpcd[337]: DHCP_OFFER received from (10.63.17.1)
Jan 1 00:00:23 imx21 local0.debug dhcpcd[337]: DHCP_ACK received from (10.63.17.1)
Jan 1 00:00:23 imx21 daemon.err netsyncd[314]: father received(10) eth0 up!
Jan 1 00:00:23 imx21 daemon.info netsyncd[314]: Dhcp_start 337 return : 0
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC0 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC1 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC2 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC3 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC0 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC1 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC2 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC3 = 8
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :PA Request
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :No state change!
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvIoctl :Fast PS Request
Jan 1 00:00:26 imx21 daemon.info klogd: PhgHhalDoM2SDMA:1661:-->P1
Jan 1 00:00:26 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PS Ind (1) in Drvmain
Jan 1 00:00:28 imx21 daemon.info netsyncd[314]: Dhcp_stop 359 return : 0
Jan 1 00:00:28 imx21 local0.debug dhcpcd[347]: sending DHCP_RELEASE for 10.63.17.5 to 10.63.17.1
Jan 1 00:00:29 imx21 local0.err dhcpcd[347]: terminating on signal 1
Jan 1 00:00:29 imx21 daemon.err netsyncd[314]: father received(12) eth0 down!
Jan 1 00:00:29 imx21 daemon.err klogd: SPI2:: drvStop :Driver Stop: disable TX queue! (usage: 2)
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvIoctl :Deauth BSSID: 00:1d:7e:18:e3:89
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVENT_DISCONNECT; setting CARRIER_OFF
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00000002, IFF_UP=0
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :device was already closed
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvOpen :opening net device
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvOpen :ERROR: Associated, but Carrier flag is set to CARRIER_OFF
Jan 1 00:00:41 imx21 daemon.err klogd: SPI2:: drvDoScan :Buero (bittorf)
Jan 1 00:00:42 imx21 daemon.err klogd: SPI2:: drvProcessScanCfm :Scan Confirm: Success 1 APs
Jan 1 00:00:45 imx21 daemon.err klogd: SPI2:: drvInitConnect :Req to connect to new WLAN network
Jan 1 00:00:45 imx21 daemon.err klogd: SPI2:: drvInitConnect :Disabling TX queue and setting CARRIER_OFF
Jan 1 00:00:45 imx21 daemon.err klogd: SPI2:: drvInitConnect :Connecting To AP...
Jan 1 00:00:45 imx21 daemon.err klogd: SPI2:: drvInitConnect :step2
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PHGHHAL_EVNT_INIT_CONNECT; setting CARRIER_ON
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :netdev->flags=0x00000003, IFF_UP=1
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :device was already opened; enabling queue
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvInitConnect :step3 : u8Status 8
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvInitConnect :step4
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvInitConnect :Successful
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvInitConnect :step6
Jan 1 00:00:46 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PS Ind (1) in Drvmain
Jan 1 00:00:54 imx21 local0.debug dhcpcd[386]: broadcasting DHCP_DISCOVER
Jan 1 00:00:57 imx21 local0.debug dhcpcd[386]: DHCP_OFFER received from (10.63.17.1)
Jan 1 00:00:57 imx21 local0.debug dhcpcd[386]: DHCP_ACK received from (10.63.17.1)
Jan 1 00:00:57 imx21 daemon.info netsyncd[314]: Dhcp_start 386 return : 0
Jan 1 00:00:57 imx21 daemon.info netsyncd[314]: NTP server request on : ntp.xs4all.nl
Jan 1 00:00:57 imx21 daemon.err klogd: SPI2:: drvIoctl :PA Request
Jan 1 00:00:57 imx21 daemon.info klogd: PhgHhalDoM2SDMA:1661:-->P0
Jan 1 00:00:57 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PS wake (0) in Drvmain
Jan 1 00:00:57 imx21 daemon.warn klogd: drvSetWOWFilter: Enable UNICAST: Disable ARP: Enable
Jan 1 00:00:57 imx21 daemon.warn klogd: Ip addr = 10.63.17.5. LMP=2
Jan 1 00:00:57 imx21 daemon.err klogd: SPI2:: drvIoctl :PA Request
Jan 1 00:00:57 imx21 daemon.err klogd: SPI2:: drvIoctl :No state change!
Jan 1 00:00:57 imx21 daemon.err klogd: SPI2:: drvIoctl :Fast PS Request
Jan 1 00:00:57 imx21 daemon.info klogd: PhgHhalDoM2SDMA:1661:-->P1
Jan 1 00:00:57 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PS Ind (1) in Drvmain
Jan 1 00:00:57 imx21 daemon.warn klogd: Sensor driver: initialize device OV7660
Jan 1 00:00:57 imx21 daemon.warn klogd: Warning: Remapping obsolete /dev/fb* minor 32 to 1
Apr 7 09:58:16 imx21 daemon.info netsyncd[314]: NTP process return code : 0
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC0 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC1 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC2 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC3 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC0 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC1 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC2 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC3 = 4
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvIoctl :PA Request
Apr 7 09:58:19 imx21 daemon.info klogd: PhgHhalDoM2SDMA:1661:-->P0
Apr 7 09:58:19 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PS wake (0) in Drvmain
Apr 7 09:58:19 imx21 daemon.info upgraded[312]: K_SW0_DWNLD_ACK
Apr 7 09:58:27 imx21 auth.info login[393]: root login on `ttyp0' from `bittorf-AP.olsr'
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC0 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC1 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC2 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11LongRetryLimitAC3 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC0 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC1 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC2 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :dot11ShortRetryLimitAC3 = 8
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :PA Request
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :No state change!
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvIoctl :Fast PS Request
Apr 7 09:59:50 imx21 daemon.info klogd: PhgHhalDoM2SDMA:1661:-->P1
Apr 7 09:59:50 imx21 daemon.err klogd: SPI2:: drvHhalEventIndicationHandler :PS Ind (1) in Drvmain
Apr 7 10:14:53 imx21 auth.info login[408]: root login on `ttyp1' from `bittorf-AP.olsr'
Apr 7 10:17:18 imx21 syslog.info -- MARK --
</pre>

=== Ausgabe von <tt>/proc/cpuinfo</tt> auf einem VP6500 ===
<pre>
# cat /proc/cpuinfo
Processor : ARM926EJ-Sid(wb) rev 4 (v5EJl)
BogoMIPS : 133.01
Features : swp half thumb fastmult
CPU implementer : 0x41
CPU architecture: ?(8)
CPU variant : 0x0
CPU part : 0x926
CPU revision : 4
Cache type : undefined 14
Cache clean : undefined 14
Cache lockdown : undefined 14
Cache unified : Harvard
I size : 16384
I assoc : 4
I line length : 32
I sets : 128
D size : 16384
D assoc : 4
D line length : 32
D sets : 128

Hardware : Freescale i.MX2 ADS
Revision : 0000
Serial : 0000000000000000

</pre>

== Software Modifikationen ==

=== Startscripts ===
Die Scripts in /etc/rc.d/" müssen im Hintergrund laufen. Tut ein Script das nicht, ist an dieser Stelle Schluß mit dem Bootvorgang.

Dann darf man als nächstes den Lötkolben anheizen und die serielle Schnittstelle ([[#UART]]) zugänglich machen.

=== Aktivierung WPA2 Unterstützung ===
Standardmäßig kann das Telefon nur WPA, dabei unterstützt es allerdings auch WPA mit AES Verschlüsselung.
Es gibt zwei verschiedene Tricks mit denen auch WPA2 aktiviert werden kann.
Allerdings wurde von einigen ein Einbruch der Verbindungsgeschwindigkeit festgestellt (scheint jedoch nur bei geringem Akkuladestand aufzutreten).

==== Trick1 ====
Mittels
vi /etc/marvell/wpa_supplicant.conf
den Texteditor starten.
Mit PageDown (Bild runter) bis zum Ende des Files gehen.
Die Zeilen
proto=WPA
pairwise=TKIP
group=TKIP
auskommentieren, indem ein # vorangestellt wird:
* cursor auf Beginn einer Zeile
* i drücken zum Einfügen
* # eintippen
* [Esc]
Sind alle Zeilen auskommentiert, dann mittels
:wq[enter]
abspeichern und Editor verlassen.

Danach neu booten.

Anmerkung: Will man sich mit dieser Änderung in einem reinen WPA2 Netz anmelden (registrieren), kann man als Verschlüsselung nur noch WEP auswählen - der Verbindungsversuch scheitert natürlich! (Hardware: Fritz!Box 7270, PHILIPS VP5500)

Also am Accesspoint WPA2 + WPA einstellen, Telefon registrieren, dann Accesspoint auf WPA2 konfigurieren.

'''Achtung!'''

'''Das Herumspielen an der wpa_supplicant.conf endet sehr schnell damit das man sich ausperrt'''

'''Um sich eine Wiederbelebung per serieller Konsole zu ersparen, ist es günstig, immer nur Einträge an die wpa_supplicant.conf hinten anzuhängen, niemals aber vorne einzufügen!'''

==== Trick2 ====
Dieser Trick funktioniert mit Accesspoints, bei denen man auch WPA Verbindungen mit AES verschlüsseln kann. Vorteil dieses Tricks ist, dass man die wpa_supplicant.conf nicht manuell editieren muss. Allerdings unterstützt nicht jeder Accesspoint WPA mit AES (aber dd-wrt kann das).

Man konfiguriert den Accesspoint zunächst mit WPA PSK und wählt AES als Verschlüsselungsalgorithmus. Jetzt meldet man das Telefon an, das Telefon erkennt richtig, dass eine WPA Verbindung vorliegt und verbindet sich per WPA und AES mit dem Accesspoint. Anschliessend konfiguriert man den Accesspoint von WPA PSK AES nach WPA2 PSK AES. Jetzt schaltet man das VP5500/6500 aus und wieder ein. Nachdem es fertig gebootet hat, verbindet es sich automisch per WPA2 PSK und mit AES Verschlüsselung. Fertig.

==== Versehentliche Aussperrung nach WPA2 Einstellversuch beheben ====

'''1. DON'T PANIC!'''

Für den Fall das man sich den Zugangsweg per wireless abgeschnitten hat, gibt es, neben dem Bau eines seriellen Adapters und der Notwendigkeit zu löten, noch eine Variante um wieder auf das Telefon zu kommen:

'''den Demo-Modus!'''

Dieser Modus war dazu gedacht die Funktionalität der VPs ohne SIP-Server ausprobieren zu können. 2 Geräte starten dazu im WLAN-AdHoc-Modus mit unterschiedlichen IP's (192.168.10.1 + 192.168.10.2 , jeweils /24 = 255.255.255.0) und machen ein IBSS-Netzwerk mit WEP-Verschlüsselung auf (Key: VP6500 = 5648751265 beim VP5500 = 7295569793).

Nun kann man auch ein einzelnes Telefon in den Demo-Modus versetzen (vorhandener neuer Menüeintrag nach dem rooten, oder per Tastenkombination "*#3 "), gibt sich eine passende WLAN und IP-Einstellungen auf dem Rechner und schon kann man wieder darauf connecten und Fehleinstellungen wieder beheben. Dummerweise wird eine zufällige IBSS-Cell-ID verwendet, aber neuere Betriebssysteme können der Zelle trotzdem beitreten. Als ESSID kann man ''demo_mode_obiwan'' verwenden.

===== Schritt für Schritt Anleitung für Linux =====

Einstellungen

'''am Telefon'''
* Telefon anschalten und per Menüeintrag oder Tastenkombination "*#3" in Demomodus versetzen (z.B. als Einstellung Handset 1)
-> IP des Telefons wird danach zu 192.168.10.1

'''am Computer'''
* Konsole öffnen
per ifconfig checken welches das WLAN-Gerät am Rechner ist (im weiteren "wlan0" genannt)
ifconfig wlan0 down
iwconfig wlan0 mode ad-hoc (ad-hoc Modus aktivieren)
iwconfig wlan0 essid 'demo_mode_obiwan' (Passende essid-Kennung setzen)
iwconfig wlan0 key 5648751265 (Key für das VP6500)
ifconfig wlan0 up
ifconfig wlan0 192.168.10.2 (setzen der IP)

man kann nun mittels:

ping 192.168.10.1

testen ob alles korrekt verlaufen ist und man eine Antwort bekommt - sollte das der Fall sein ist man '''fertig!'''

Nun kann man per telnet oder ssh, mit den üblichen Benutzerkennung und dem Passwort, auf die IP 192.168.10.1 connecten und die Probleme beheben.

=== Menüs ===
==== Hauptmenu ====

Das File
/usr/local/etc/defaultbuttons.conf
enthält unter anderm die definition des Hauptmenus.

Hierfür ist der Abschnitt Menu besonders interessant.
[Menu]
1 = Applications/camera.desktop
2 = Applications/callhistory.desktop
3 = Applications
4 = Settings
5 = Applications/addressbook.desktop
6 = Settings/RingProfiles.desktop
Columns = 3
Default = 5
Map = 123456789*0#
Rows = 2

'Rows' und 'Columns' geben an, wieviel Reihen und Spalten das Hauptmenu hat.
Über die Zuweisungen 1 bis (Columns * Rows) kann man dann den Menüpositionen die Menüpunkte zuweisen.
Die Menupunkte sind definiert in den Verzeichnissen unter
/usr/local/apps
gibt man nur ein Verzeichnis an, dann erscheint ein Submenü, dessen Icon und Name in der .directory -Datei des entsprechenden Ordner definiert ist.
direkte Menupunkte haben Dateinamen mit der Endung .desktop
'Default' bestimmten vorselektierten Eintrag.

Hier ein weiteres Beispiel für ein angepasstes Menu:
[Menu]
1 = Applications/addressbook.desktop
2 = Applications/callhistory.desktop
3 = Applications/sysinfo.desktop
4 = Applications
5 = Settings
6 = Games
7 = Applications/camera.desktop
8 = Applications/photoedit.desktop
9 = Applications/manualsub.desktop
Columns = 3
Default = 5
Map = 123456789*0#
Rows = 3

Der Ordner Games ist (momentan ;) leer.

==== Genereller Aufbau Menü-Einträge ====
Die Einträge für die Menüs sind im Filesystem abgelegt:

* Settings: /usr/local/apps/Settings
* Applications: /usr/local/apps/Applications
* Klingeltöne: /usr/local/etc/SystemRingTones/

Die Dateien haben die Endung ".desktop" und sind normale Textdateien, die die relevanten Infos enthalten.

Ein Beispiel aus dem Settingsordner:
[Translation]
File=QtopiaSettings
Context=Sound
[Desktop Entry]
Type=Application
Exec=sound
Icon=Sound
Name[]=Sound
CanFastload=0

Der Abschnitt 'Translation' gibt an in welchem File, die Lokalisationsdaten stehen.

Der Abschnitt 'Desktop Entry':
* Type: Typ des Eintrages
** Application für Anwendungen
** audio/x-wav für Klingeltöne
* Exec: Anwendung, die ausgeführt werden soll
* Icon: Icon, das im Menü benutzt wird.
** Pfad ist meist: /usr/local/pics/[Exex]/[Icon].png
** manchmal aber auch: /usr/local/pics/icons/[14x14|16x16|22x22]/[Icon].png
* Name[]: Name im Menü, wird über das in Translation angegebe File und Context aufgelöst. Dies wird verhindert, wenn die Klammern wegelassen werden, was das Einfügen eigener Einträge ermöglicht

Hier ein Textfile mit allen desktop-Files als Referenz: [[File:alleDesktopFiles.txt]]

==== Versteckte Menüeinträge ====
in den oben genannten Ordnern existieren ein paar Dateien mit der Endung '.desktopMASK'.
Benennt man diese um, werden die Einträge nach einem Neustart im Menü freigeschaltet.

folgendes an der Kommandozeile eingeben:
cd /usr/local/apps/Settings
mv datetime.desktopMASK datetime.desktop
mv callforward.desktopMASK callforward.desktop
mv calloptions.desktopMASK calloptions.desktop
mv resetparam.desktopMASK resetparam.desktop
mv subkpncode.desktopMASK subkpncode.desktop

Dies aktiviert folgende Optionen:
* Datums/Zeit-Einstellung
* Anrufweiterleitung
* Anrufoptionen
* Parameter zurücksetzen
* Number Switch

Die nützlichsten sind wohl die ersten Einträge.
Bei dem "Number Switch" ist unklar, was er bewirken soll. Beim Start wird ein Code abgefragt.

Weiterhin kann im Verzeichnis /usr/local/apps/Applications eine [[File:demomode.desktop]] anlegen.

Hierfür ist folgende Prozedur nötig:
* im Terminal
 cd /usr/local/apps/Applications
 vi demomode.desktop

* i drücken
* folgendes Textfragment einfügen
 [Translation]
 File=QtopiaApplications
 Context=DemoMode
 [Desktop Entry]
 Exec=demomode
 Icon=Camera
 Type=Application
 Name[]=DemoMode
* [Esc]
* :wq [Enter]

Dies schaltet einen Demo-Modus frei.

===== Französisch =====
Es gab die Geräte wohl auch in Frankreich von der France Telekom.
Zumindest sind entsprechende monitor und upgrade Referenz-Dateien
vorhanden in denen das steht. Daher wohl auch die Französischen
Sprachdateien, die zwar auf dem Gerät sind, allerdings in einem
Unterverzeichnis, so das sie nicht auswählbar sind.

Um diese Dateien zu aktivieren:

cd /usr/local/i18n
mv NOTUSED/fr .

Nun ist auch noch französisch als Sprache verfügbar.

==== Eigene Menüeinträge ====

Es besteht die Möglichkeit Menüeinträge anzulegen, durch die Shellskripte ausgeführt werden. Im Folgenden ist dieses Vorgehen am Beispiel des ein- und ausschaltens von SSH beschrieben.

===== SSH aktivieren & deaktivieren =====

*'''Achtung! Folgendes Vorgehen kann das Gerät bricken, falls Telnet deaktiviert ist und irgendwas mit SSH schief läuft!'''
*Die folgenden beiden Dateien repräsentieren die Menüeinträge und rufen ''enablessh'' bzw. ''disablessh'' auf.
:*''/usr/local/apps/Applications/enablessh.desktop'':
[Translation]
File=QtopiaApplications
Context=enablessh
[Desktop Entry]
Exec=enablessh
Icon=Camera
Type=Application
Name[]=Enable SSH
:*''/usr/local/apps/Applications/disablessh.desktop'':
[Translation]
File=QtopiaApplications
Context=disablessh
[Desktop Entry]
Exec=disablessh
Icon=Camera
Type=Application
Name[]=Disable SSH
*''enablessh'' und ''disablessh'' sind Shellskripte, die in ''/usr/local/bin/'' liegen und folgendes enthalten:
:*''/usr/local/bin/enablessh'':
#!/bin/sh
touch /var/log/lastlog
/etc/rc.d/init.d/S99dropbear restart
exit(0)
:*''/usr/local/bin/disablessh'':
#!/bin/sh
/etc/rc.d/init.d/S99dropbear stop
exit(0)
*Nach einem Neustart des Telefons sollten im Menü ''Anwendungen'' die zwei neuen Menüpunkte auftauchen.

=== Grafische Anpassungen ===
So gut wie alle Grafiken liegen im Verzeichnis /usr/local/pics und können beliebig ausgetauscht werden (gleicher Dateityp, gleiche Größe).

Einige besonders interessante werden hier aufgeführt:

===== Eigene Startup/Shutdown-Animation =====

Die Animation beim Starten oder Herunterfahren sind normale (animierte) GIFs. Diese findet man in

/usr/local/pics/qpe

Die Links "splash.gif" und "goodbye.gif" zeigen auf die tasächlich zu verwendenen Dateien ("splash-chuck.gif", "goodby-chuck.gif").
Man kann sein eigenes animiertes GIF im Format 176x220 Pixel raufladen und die
splash.gif entsprechend neu verlinken. Dazu löscht man zuerst die alte
mit:

rm /usr/local/pics/qpe/splash.gif

Anschliessend erzeugt man den Link neu, dabei zeigt er dann auf die
eigene Datei:

ln -s /pfad/zur/eigenedatei.gif /usr/local/pics/qpe/splash.gif

Danach wird dann bei jedem Neustart die eigene Animation angezeigt.
Analog hierzu mit der goodbye.gif.

Also, man packe das Bild auf einen Webserver. Dann am Gerät über telnet
anmelden und:

<syntaxhighlight lang="c">
cd /usr/local/pics/qpe/
wget http://dein.server/woauchimmer/Matrix5.gif
rm /usr/local/pics/qpe/splash.gif
ln -s Matrix5.gif splash.gif
</syntaxhighlight>

Die GIF Animation kann bis zu 176x220 Pixel groß sein.
Kleinere (möglicherweise auch größere) Bilder werden zentriert.
<gallery>
Bild:walking_baby_tux.gif
Bild:custwakeup2.gif
Bild:custgoodbye2.gif
Bild:94vw4.gif
Bild:1_Matrix--16984.gif
Bild:1_Matrix--16985.gif
Bild:3.gif
Bild:ClanSpider2.gif
Bild:TS12.gif
Bild:Matrix5.gif
Bild:qtopia3.gif
Bild:qtopia0.gif
</gallery>

===== Eigener Boot/Update-Screen =====

Der Boot-Screen, oder der Update-Screen liegen als Rohdaten vor.
/user_data/data/welcome.rgb565
/usr/local/startup_V4.20/update.bin

Weitere Beispielbilder:
/user_data/prod/data/lcd_test_card1.bin
/user_data/prod/data/lcd_test_card2.bin

Diese werden direkt in den Framebuffer geschrieben.
Daher müssen sich diese genau ein bestimmtes Format halten:
* Größe 240 x 220 (Das Display ist 176 x 220, der Rest ist also nicht zu sehen)
* 16bit pro Pixel RGB565

Um solch ein Bild zu erstellen sind folgende Schritte notwendig:
# Ein Bild in Gimp mit 176x220 erstellen
# das Bild vertikal spiegeln
# Bild->Leinwandgröße auf 240x220 erweitern (Bilddaten ganz nach links)
# Datei->Kopie speichern...
# Als Windowsbitmap -> erweiterete Optionen -> 16bit R5G6B5
# BMP-Header entfernen (dies kann auch auf dem Telefon gemacht werden)
 tail -c 105600 input.bmp > output.raw

Von der Kommandozeile kann auch manuell das Bild in den Framebuffer geschrieben werden.
cat /user_data/prod/data/lcd_test_card1.bin > /dev/fb0

=== Wichtige Verzeichnisse ===

==== Adressdaten ====
<syntaxhighlight lang="xml">

# cat /user_data/home/Applications/addressbook/addressbook.xml
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE Addressbook ><AddressBook>
<Groups>
</Groups>
<Contacts>
 <Contact
 Uid="-1269720893"
 Categories="-1269431263;-1266109093;-1266109094"
 FirstName="ich"
 FileAs="ich"
 JobTitle="cc"
 Department="dep"
 Company="aa"
 BusinessPhone="55"
 BusinessFax="77"
 BusinessMobile="66"
 HomePhone="55"
 HomeMobile="11"
 HomePc="12"
 HomeData="13"
 HomeFax="14"
 BusinessStreet="street"
 BusinessCity="city"
 BusinessState="state"
 BusinessZip="zip"
 BusinessCountry="country"
 BusinessPager="88"
 Office="office"
 Profession="prof"
 Assistant="ass"
 Manager="man"
 HomeStreet="ptjml"
 HomeCity="cit"
 HomeState="stat"
 HomeZip="zi"
 HomeCountry="coun"
 Spouse="spouse"
 Gender="1"
 Birthday="20100322"
 Anniversary="20100429"
 Children="child"
 Notes="gakm"
 CompanyPronunciation="bb"
 BUSINESS_CONTACT=""
 photofile="ci-1269721575-0.jpg"
 qdl-private-data=""
 tone="/usr/local/etc/SystemRingTones/16-Tetris.desktop"
 />
 <Contact Uid="-1269554029"
 FirstName="VoIP"
 LastName="Phone1"
 FileAs="VoIP Phone1"
 HomeMobile="**621"
 tone="/usr/local/etc/SystemRingTones/15-Techno2.desktop" />
 <Contact Uid="-1269554032"
 Categories="-1269431263"
 FirstName="VoIP"
 LastName="Phone3"
 FileAs="VoIP Phone3"
 HomeMobile="**623"
 BUSINESS_CONTACT=""
 qdl-private-data=""
 tone="/usr/local/etc/SystemRingTones/08-Celtrelax.desktop" />
</Contacts>
</AddressBook>

</syntaxhighlight>

UID ist wohl egal, solange sie nicht zweimal vorkommen.

Die Beschränkung auf 500 Adressbucheinträge kann man auch aufheben:
<pre>maxEntries = 500</pre> in der <pre>Contacts.conf</pre>

Die Kategorien stehen in <pre>/user_settings/Categories.xml</pre>:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE CategoryList>
<Categories>
 <Category id="-1269431263" name="_Personal" />
 <Category id="-1269431262" name="_Business" />
</Categories>
</syntaxhighlight>

Wenn man einem Kontakt eine bestimmte Kategorie zuordnet, dann wird die ID dieser Kategorie im Attribut "Categories" des Kontakts eingetragen (s.o.). Wenn die Kategorie BUSINESS gewählt wird, steht im Attribut "BUSINESS_CONTACT" eine "1".

Ein Einrücken der Attribute mit TABs in den Dateien ist übrigens nicht erlaubt!

Die Software des Telefons wertet die XML Datei bei jedem Zugriff neu aus. Es ist also möglich, die Datei im laufendem Betrieb zu ändern (z.B. per Script).

Um VCards in das XML Format zu konvertieren gibts es im Forum folgendes kleines C-Programm: [http://www.mikrocontroller.net/attachment/74583/VCardsToXML.c] [http://www.mikrocontroller.net/attachment/highlight/74583]

==== Fotos & Videoschnappschüsse ====

Alle Bilder die mit der Kamera aufgenommen werden, sowie Schnappschüsse die während eines Videocalls aufgenommen wurden, befinden sich in folgendem Verzeichnis:
 /user_data/home/Documents

Die Bilder sind dabei nach folgendem Namensschema benannt:

 DD-MM-YYYY-hh:mm:ss.jpg

Tag (DD) und Monat (MM) können auch einstellig sein.

=== Klingeltöne ===

Die Klingeltöne liegen, wie oben beschrieben unter:

/usr/local/etc/SystemRingTones/

Es sind .wav Dateien mit (16Khz, 16Bit, Mono), welche sich z.B. mit MhWaveEdit (Linux/GTK) oder auch Audacity recht komfortabel erzeugen lassen.

Auch .wav Dateien mit 22050Hz werden problemlos abgespielt (ein wenig bessere Qualität als 16000hz) und sind als Klingeltöne nutzbar. Dateien mit 44100Hz spielt es leider nur 'ruckelnd' ab (32000Hhz nicht getestet).

Zusätzlich zu den Audio Dateien müssen noch im selben Verzeichnis entsprechende *.desktop dateien angelegt werden, damit alles korrekt ins Menü integriert wird.
Eine für den fiktiven 16. Klingelton erzeugte Datei "16-Tetris.desktop" könnte den folgenden Inhalt haben:

 [Desktop Entry]
 Categories =
 File =16-Tetris.wav
 Name[] =16-Tetris
 Type = audio/x-wav
 [Translation]
 File=QtopiaRingTones
 Context=16-Tetris

Nach dem Anlegen der Dateien sollte sie dann im Menü auftauchen und auswählbar sein.

=== Systemtöne ===

*Sämtliche Systemtöne liegen unter ''/usr/local/sounds/'' und lassen sich problemlos durch andere Dateien ersetzen.
*z.B.:
**''charge.wav'' - Ton, wenn Gerät in die Basisstation gesetzt wird

=== Timeserver ===

http://www.mikrocontroller.net/topic/170483#1645101
Unter /usr/local/data steht in der monitor.cfg und monitor_ref_KPN.cfg
die Adressen der Zeitserver "ntp.xs4all.nl" und "130.142.110.71". Diese
könnte man z.B. auf "ptbtime1.ptb.de" und "ptbtime2.ptb.de" ändern.

(http://www.mikrocontroller.net/topic/170483#1649594)
das telefon benutzt *nicht ntp* sondern das time-protokoll auf port 37 -
time.fu-berlin.de (bzw. chronos.zedat.fu-berlin.de) kann man als server nehmen.

vi Tipp hilfe:
<syntaxhighlight lang="c">
vi /usr/local/data/monitor.cfg
:%s/ntp.xs4all.nl/time.fu-berlin.de/g
:%s/130.142.110.71/130.133.1.10/g
</syntaxhighlight>

Aufgefallen ist, dass sich Telefone mit fest eingestellter IP nicht automatisch
die Uhrzeit abrufen. Stellt man das Telefon auf DHCP, stellt sich die Uhr
auch ohne Timeserver Modifikation auf die richtige Uhrzeit ein.

Wer lieber einen NTP-Client einsetzen möchte findet unter dem Link für [[#Weitere_Konsolenkommandos]] ein Paket mit ntpd oder auch ntpdate für den schnellen Zeitabgleich via Konsole:
 ntpdate pool.ntp.org

=== Zusätzliche Software ===
==== Dropbear (SSH-Server) installieren ====

# Mit telnet auf dem Gerät einloggen
# folgendes in die Kommandozeile kopieren

<pre>
 cd /
 wget http://www.mikrocontroller.net/attachment/74656/dropbear.tgz
 tar -xzf dropbear.tgz
 rm dropbear.tgz
 cd /etc/rc.d/init.d
 mv dropbear S90dropbear
 ./S90dropbear start

</pre>

Das Kommando in Zeile 6 (mv ...) ist notwendig damit dropbear bei jedem Reboot automatisch gestartet wird.

Prüfen ob dropbear gestartet ist und läuft:

<pre>
# ps
PID Uid Stat Command
136 root S /usr/sbin/dropbear
</pre>

Bei jedem Login sucht dropbear nach der /var/log/lastlog, daher sollte man abschließend noch ein

<pre>
 touch /var/log/lastlog
</pre>

machen, um diese Datei anzulegen. Damit verschwinden auch die entsprechenden Fehlermeldungen im logread.

==== Nano 2.2.3 installieren ====

* Mit telnet auf dem Gerät einloggen
* folgendes in die Kommandozeile kopieren
 cd /usr/bin
 wget http://www.mikrocontroller.net/attachment/74023/nano
* Mit folgendem Befehl den Editor ausführbar machen:
 chmod +x /usr/bin/nano
* Nun ist vi Geschichte ;-)

Ggf. kann der Fehler "Error opening terminal: xterm-color" auftreten wenn nano gestartet wird, in diesem Fall hilft folgendes:

* /root/.bashrc öffnen (mit vi :-)
* "export TERM=xterm" in die Datei schreiben
* ausloggen / einloggen

==== OpenVPN 2.0.9 installieren ====

* Mit telnet auf dem Gerät einloggen
* folgendes in die Kommandozeile kopieren
 cd /
 wget http://www.mikrocontroller.net/attachment/74380/openvpn.tar.gz
 tar -xzf openvpn.tar.gz
 depmod
 mknod /dev/net/tun c 10 200

==== OpenVPN 2.1.1 installieren ====

* Mit telnet auf dem Gerät einloggen
* folgendes in die Kommandozeile kopieren
 cd /
 wget http://www.mikrocontroller.net/attachment/74395/openvpn-2.1.1.tar.gz
 tar -xzf openvpn-2.1.1.tar.gz
 depmod
 mknod /dev/net/tun c 10 200

==== Tinc 1.0.12 installieren ====

* Mit telnet auf dem Gerät einloggen
* folgendes in die Kommandozeile kopieren
 cd /
 wget http://www.mikrocontroller.net/attachment/74396/tinc-1.0.12.tar.gz
 tar -xzf tinc-1.0.12.tar.gz
 depmod
 mknod /dev/net/tun c 10 200

==== Weitere Konsolenkommandos ====

Auf http://thinksilicon.de/57/Hacking-the-VP6500.html finden sich einige nützliche Konsolentools. Darunter sind bc, lsof, file, curl, mc (bzw. mcedit), hexedit, mktemp, rsync, tcpdump, crond (mit crontab) und ntpd.
* Hinweis zu tcpdump; muss folgendermaßen ausgeführt werden:
 tcpdump -U root

=== simpler WLAN-Switcher ===

Ohne tiefer gehende GUI-Programmiererfahrungen bei Qtopia zu haben, kann man sich mit folgendem WLAN-Switcher behelfen:

Im Script /user_data/prod/config_ats.sh stehen viele Befehle, wie man mittels ''config code'' Einstellungen vorschreiben kann. Dies habe ich mir mit folgenden eigenen Scripten zu nutze gemacht:

'''/root/switch_wlan.sh'''
#!/bin/bash
#================================================
# WLAN-Switcher
#================================================
CONFIG_CODE=`cat /user_data/config_code.txt`
cp -f /usr/local/data/wpa_supplicant_ref_${CONFIG_CODE}.conf /user_data/wifi/wpa_supplicant.conf

* kopiert Anhand des ''config code''s die wpa_supplicant.conf
* es muss für jeden ''config code'' eine wpa_supplicant_ref_<''config code''>.conf vorhanden sein, am besten dazu die aktuelle /user_data/wifi/wpa_supplicant.conf dorthin kopieren

'''/root/set_config_code.sh'''
#!/bin/bash
echo "$1" > /user_data/config_code.txt

* schreibt den ersten übergebenen Parameter in die Datei /user_data/config_code.txt

'''/usr/local/bin/set2XXX'''
#!/bin/sh
/root/set_config_code.sh XXX
/root/switch_wlan.sh
reboot

* XXX durch den ''config code'' ersetzen
* Script, welches als Applikation gestartet wird
* derzeit leider keine "on-the-fly"-Eingabe des ''config code''s möglich, daher muss für jedes WLAN ein Script vorhanden sein

'''/usr/local/apps/Applications/set2YYY.desktop'''
[Translation]
File=QtopiaApplications
Context=set2XXX
[Desktop Entry]
Exec=set2XXX
Icon=Camera
Type=Application
Name[]=Enable YYY

* XXX durch den ''config code'' ersetzen (gleicher Scriptname wie oben)
* YYY durch einmaligen Namen ersetzen
* Diese Datei erscheint unter dem Name[] im Applications-Menü

Theoretisch kann man mit dieser Methode auch problemlos zwischen mehreren SIP-Einstellungen und vielen weiteren Telefoneinstellungen umschalten (siehe Dateien in /usr/local/data) - der DemoMode funktioniert nach dem gleichen Prinzip.

== Buildumgebung erstellen ==

Bislang ist die Erstellung von GUI-Applikationen (QTopia) noch nicht auf einfache Weise möglich. Das größte Problem ist, dass der Quellcode der Video-Telefon-Anwendung zum größten Teil zur Verfügung steht. Das Erstellen von Kommandozeilen-Anwendungen geht aber schon problemlos.

=== Windows ===
Die verwendete ARM-Entwicklungsumgebung basiert auf gcc. Mittels cygwin kann diese zwar auch als Win32-Anwendungen gebaut werden, dies ist aber in hohem Maß unüblich.

Am besten eine aktuelle Version von Debian oder Ubuntu in "vmware player" oder "virtual box" installieren. Wenn man die virtuelle Maschine nur zum Compilieren verwendet, reicht eine kompakte Kommandozeilen-Version (z.B. Ubuntu Server 9.10). Fertige virtuelle Machinen, im vmware-Marketing-Sprech gerne auch "virtual appliances" genannt, sind reichlich verfügbar (z.B. http://www.vmware.com/appliances/directory/70918).

=== Freetz-Linux ===
Für Fritzbox-Besitzer besonders geeignet ist das Freetz-linux, welches man im IP-Phone-Forum finden kann (-> http://www.ip-phone-forum.de/showpost.php?p=1400234&postcount=1).
Dieses kann zum Erstellen von Freetz-Images einerseits und andererseits als Buildumgebung benutzt werden. So spart man sich eine zweite VM.

Die VM selbst braucht nur gestartet werden, den Rest macht man am Besten von seiner gewohnten Umgebung aus.
Mittels Samba kann einfach per Windowsnetzwerk auf das Home-Verzeichnis zugriffen werden und per SSH kann einfach eine Shell (UTF als Codierung einstellen, dann stimmen auch die Sonderrzeichen) geöffnet werden.
Es muss sichergestellt werden sein, dass die VM zugriff auf das lokale Netzwerk, sowie das Internet hat (am besten mit einem 'ping google.com' überprüfen). Bei mir ging es eigenartiger weise erst, als ich die virtuelle Netzwerkkarte in den VM-Settings auf NAT gestellt habe.

Benutzername und alle Kennwörter sind 'freetz'

==== Installation und Test der VP5500 Toolchain ====
Installation der Buildumgebung:
sudo mkdir -p /opt/VP5500/toolchain
cd /opt/VP5500/toolchain
sudo wget http://www.handhelds.org/download/projects/toolchain/arm-linux-gcc-3.3.2.tar.bz2
sudo tar xjf arm-linux-gcc-3.3.2.tar.bz2
sudo rm arm-linux-gcc-3.3.2.tar.bz2
sudo ln -s /opt/VP5500/toolchain/usr/local/arm /usr/local/arm

Nach einem sudo-Kommando muss eventuell das Passwort eingegeben werden, weswegen die Befehle einzeln eingegeben werden sollten (oder man öffnet am Anfang eine sudo shell, dann kann man das auch weglassen.

Test der Buildumgebung:
cd ~
wget http://www.mikrocontroller.net/attachment/73161/helloworld.tgz
tar -xzf helloworld.tgz
rm helloworld.tgz
cd helloworld
make
Dannach sollte im ~/helloworld verzeichnis ein neues executable liegen, was vom Hostrechner einfach via Netzwerkfreigabe (\\freetz-linux\helloworld) und via WinSCP auf das Telefon kopiert werden kann.

==== Freetz-Linux eigentlicher Anwendungszweck ====
wer das Ding auch zum Bauen von Freetz-Images zum Erweitern seiner Fritz-box benutzen will muss sich zuerst ein Freetz runterladen.
Folgende Schritte machen dies:
cd ~
svn checkout http://svn.freetz.org/trunk freetz-trunk
Dannach gibts im Home-Verzeichnis das aktuelle Freetz im Verzeichnis 'freetz-trunk'.
Konfigurieren mit 'make menuconfig' und Image erstellen mit 'make'.
Wenn alles gut geht kann man das image dann vom Hostrechner aus der Windowsfreigabe '\\freetz-linux\freetz-trunk\images' rausholen und auf die Box spielen.

Für detailiertere Infos bitte direkt bei Freetz nachschlagen:
http://trac.freetz.org/

=== Linux ===
Die bisher bekannten, mit VP5500 und VP6500 ausgelieferten Software-Versionen, basieren auf einer etwas älteren "gcc 3.3.2-ARM-Toolchain". Eine passende Toolchain für ein x86-basiertes Entwicklungssystem ist unter http://www.handhelds.org/download/projects/toolchain/arm-linux-gcc-3.3.2.tar.bz2 zu finden.

Unter Debian-basierten Linux-Distros kann dieses Archiv z.B. nach /opt/VP5500/toolchain entpackt werden (einige der Makefiles im Forum setzen diesen Speicherort voraus). Es ist jedoch zu beachten, dass diese Version der Toolchain auch über den Pfad /usr/local zugänglich sein sollte. Dazu kann mittels "ln -s /opt/VP5500/toolchain/usr/local/arm arm" in /usr/local ein Symlink auf den eigentlichen Speicherort gesetzt werden.

==== Hello World ====
Christian Klippel (ChrisK) hat unter http://www.mikrocontroller.net/attachment/73161/helloworld.tgz ein "Hello World" bereitgestellt, mit dem sich die Toolchain testen lässt und dessen "Makefile" und "Makefile.local" als Grundlage für eigene Versuche dienen kann.

Das Archiv wird in ein lokals Verzeichnis (z.b. ~/helloworld) entpackt und dort durch Eingabe von "make" compiliert.

Zum Testen muss das Binary natürlich auf das Zielsystem übertragen werden. Wenn auf dem Entwicklungssystem ein http-Server oder ein ssh-Server läuft, kann man das Binary einfach in ein darüber zugängliches Verzeichnis kopieren es anschließend in einer telnet-Sitzung vom Verzeichnis /tmp aus mittels wget oder scp laden. Zum Test muss die Datei mittels "chmod +x helloworld" ausführbar gemacht werden, bevor sie mit "./helloworld" ausgeführt werden kann.

Mittels eines ftpd (z.B. http://www.mikrocontroller.net/attachment/73780/troll-ftpd_1.28-cg2_arm.tgz) oder sshd (z.B. Dropbear von http://vp6500.bd8.nl/) auf dem Zielsystem, kann man das Kopieren auch vom Entwicklungssystem aus durchführen.

==== Anpassen kleinerer Konsolen-Tools auf Cross-Compilierung ====
Die Makefiles von kleineren Projekten sind häufig nicht so sauber aufgebaut wie das helloworld-Beispiel, so dass man sie leichter ersetzt, als ändert. Am Beispiel von micro_httpd (http://www.acme.com/software/micro_httpd/ , http://www.mikrocontroller.net/attachment/73175/micro_httpd.tar.gz) kann leicht nachvollzogen werden, wie man den modularen Ansatz vom "Hello World"-Beispiel übernehmen kann (Makefile -> Makefile + Makefile.local).

= Sonstiges =

== Hardware + Software Versionen ==

Listet mal eure Hardware- und Softwareversion aus dem '''Applications''' => '''System Info''' Menü auf, wenn sie hier noch nicht stehen!

=== VP5500 ===

{| class="wikitable"
|-
! Hardware Version !! Date !! Software Version
|-
| ind5 ||0645 || 4.20
|-
| ind5 ||0647 || 4.20
|-
| ind5 ||0648 || 4.20
|-
| ind5 ||0649 || 4.20
|-
| ind5 ||0702 || 4.20
|-
| ind5 ||0703 || 4.20
|}

=== VP6500 ===

{| class="wikitable"
|-
! Hardware Version !! Date !! Software Version
|-
| ind3-v2 || 0711 || 3.22
|-
| ind3-v2 || 0713 || 3.22
|-
| ind3-v2 || 0716 || 3.22
|}
= Wünsche und Nutzungsideen =

Wer was äußern möchte, kann das hier reintippeln, zwecks Bündelung Interessen und Kräfte. Muss ja keiner das Rad 3x erfinden und man kann schaun was der ein oder andere macht.
Eine Status und Kontaktangabe bei Sachen die in Arbeit sind wäre toll.

== Software ==

* Audiostream-Player
* MP3
** madplay gibt es [http://www.mikrocontroller.net/topic/172616#1704777 hier], der automatische Stromsparmodus stört aber noch
* Browser und sei es nur für Wikipedia und Google
* Mailclient
* T9 Unterstützung bei Texteingabe
* Skypebenutzung
* Nutzungsmöglichkeit als Wireless-Webcam
* WLAN-Repeater
** besser: [http://freifunk.net Freifunk-] bzw. [http://www.olsr.org OLSR-Daemon]
* Wecker
* Voice-Crypto
* Unterstützung von mehreren WLAN Profilen, damit man das Gerät an mehreren APs betreiben kann ohne jedesmal SSID / Key neu eingeben zu müssen. (Sollte durch mehrere Einträge in der wpa_supplicant.conf möglich sein. Diese wird aber bei Änderungen über's Menü komplett überschrieben. Alternative: [[#simpler WLAN-Switcher]])
* Unterstützung von mehreren SIP Profilen, um z.b. von einem SIP-Anbieter auf den anderen zu wechseln. Ideal wäre, wenn man 2 SIP Profile gleichzeitig nutzen könnte
* YouTube Client, vgl. mit "MiniTube Linux"
* 'ne aktuelle Firmware? z.B: mit 2.6er Kernel und Android?
* Unterstützung für WLANs mit 802.1x die WPA2 verschlüsselt sind reparieren bzw. passende Konfig finden (unverschlüsselt geht schon)

== Hardwarerweiterungen ==

* Speichererweiterung
* USB Anschluss
* Blauzahn
* zusätzlicher Anschluss um eine andere Videokamera anzuschließen mit CINCH

== Nutzungsideen ==

* VoIP Phone und Webcam (nahliegend)
* WLAN-Finder
* Repeater
* mobiles Infogerät mit Wikizugriff und Mailpush in der Wireless-Bubble
* Türöffner, Ferncontroller
* Robohirn
* WLAN-Radio
* Video(Streaming)-Client in Verbindung mit VDR
* Barcode-Reader
* als Fernbedienung für PC (Winamp/Mediaplayer/VLC...
* Streamclient und Fernbedienung für DBOX2 mit Linux

[[Kategorie:Projekte]]
[[Kategorie:Datenübertragung]]

Entwicklungsboard mit PIC

2013-05-22T16:16:02Z

Mthomas: Schützte „Entwicklungsboard mit PIC“: Weblink-Spam ([edit=autoconfirmed] (bis 22. Juni 2013, 16:16 Uhr (UTC)) [move=autoconfirmed] (bis 22. Juni 2013, 16:16 Uhr (UTC)))

[[Kategorie:Wettbewerb]]

''von Denys Maiier''

{{Wettbewerb Header}}

[[Datei:brd mini.jpg]] [[Datei:Entwicklungsboard_gefräst.JPG]]

== Vorwort ==

Dieses Kit dient als Lehrmittel für Studenten, Schüler und diejenigen, die Grundlagen und Funktionalität der Mikroprozessortechnik, am Beispiel des Microcontrollers der PIC18 Familie von der Firma Microchip, beherrschen möchten. Mit Hilfe der im Kit erhaltenen Modulen können folgende Programmieraufgaben gelöst werden:

• Ein- und Ausgabe über I/O Ports und Kontrolle der Ausgabe über 16 LED’s

• Externe Programmunterbrechung über 3 Interruptquellen(3 Buttons)

• Verbindung mit dem PC über UART

• Datenübertragung über IR

• Tonausgabe (Buzzer)

• Datenübertragung über SPI und I²C im Halb-Duplex-Mode

• Schrittmotorensteuerung

• Dynamische Tastatureingabe

• AD- Umwandlung

• Datenausgabe auf dem HD44780 Display

== Projektinhalt ==

a. Mainboard
b. SPI-Board
c. I²C-Board
d. Com-Board
e. Hitachi LCD Board

== Hardware ==

Projekt der Entwicklungsplatine basiert sich auf dem PIC 18F4520 Microcontroller und besteht aus dem Main-board und Peripherie-Modulen , die mit Hilfe der Kabelverbindungen mit Main-board verbunden werden.

== Mainboard ==

Mainboard verfügt über 33 I/O Ports, die allerdings spezifisch benutzt werden können. Die PORTB I/O Pins können softwaremäßig an die innere Pull-Up Widerstände angeschlossen werden. Das MCU wird über Quarz/Keramik Oszillator taktversorgt.Die Kapazität der Kondensatoren liegt im Bereich 15-25pF und von den Quartzeigenschaften abhängig.Die empfohlene Größe steht üblicherweise im Datenblatt. Buzzer SG1 kann anhand dem Jumper JP2 an Port RE2 angeschlossen werden. Drei Tasten (INT1-INT3) zusammen mit Widerständen R69 bis R71 und R20 bis R23 ermöglichen die externe Programmunterbrechung. Mikrocontroller PIC18 verfügt über ICSP Modul und kann über ICSP Input direkt im Board programmiert werden. 16 separat gesteuerte LED sind über JP5 und JP10 an die Output-Pins von PIC18 anzuschließen.

''Mainboard Modul''
[[Datei:Mainboard V1.0.jpg]]

PIC 18 verfügt über Master Synchronous Serial Port und kann im SPI oder I²C Modus arbeiten. Dieses Entwicklungsboard hat zwei Module womit die Grundlagen der seriellen Übertragung geübt werden können.

== SPI-Interface Board ==

''SPI Modul''
[[Datei:SPI Modul.png]]

Wenn MSSP als SPI eingestellt ist, sollen die Pins RC3-RC5 des PIC18 entsprechend softwaremäßig eingestellt und mit ISP – Modul verbunden werden. Benötigt wird auch noch ein Port-Pin des MCU um den Chip Select Eingänge der MCP23S17 zu steuern.
SPI Interface Modul – Platine ermöglicht separate Steuerung von zwei MCP23S17 Bausteinen, die allerdings mit dem gemeinsamen Chip Select Signal und unterschiedlichen HW-Adressen (000 und 111) als I/ O Serial – zu –Parallel Treiber funktionieren.
IC2 ist mit 4 Binär zu Dezimal Wandler ausgestattet und wird zur Ausgabe der 16 Bit Daten benutzt.
Die ersten 8 Bit vom IC3 können über JP15 mit zwei L293D Schritt-Motoren –Treiber beschaltet werden.
Die Bits 9 bis 16 dienen als Inputs und können mit externer Tastatur 4x4 angeschlossen werden.

== I²C Interface Board ==

''I²C Modul'' [[Datei:I2C Interface.jpg]]

Wenn MSSP im I²C Modus ist, wird die I²C Interface Platine benötigt. Entsprechende MCU Pins RC3 und RC4 sollen dann mit I2C-Input beschaltet werden.
Über I²C Protokoll können folgende Peripherie-Bauteile angesteuert werden: Real Clock Modul, EEProm, ADU Umwander mit 4 über Potis beschalteten Analog- Eingängen, Serial-to-Parallel Wandler mit 8 LED , Serial-to-Parallel Wandler mit 4x4 Tastatur und ein Temperatursensor.
Zugang zu den einzelnen Bauelementen erfolgt über verschiedene Adressen der Peripherie. Damit werden die Kollisionen vermieden.

''HW-Adressen der I²C Peripherie''
[[Datei:HW-Adresse.bmp]]

== Comm-Modul ==
RS-232& USB Modul [[Datei:USB&RS-232&Keyboard.jpg]]

Peripherie- Com-Modul ermöglicht die Datenübertragung zwischen dem PC und MCU über eine UART Schnittstelle. Dafür müssen gewisse Änderungen im Software vorgenommen werden. Außerdem sollen die Port-Pins RC6 und RC7 mit den entsprechenden Kontakten der JP18 JP17 verbunden sein(Siehe Videobeispiel "Anschluß mit PC über USB").

== LCD-Modul ==

''PVC200403P''[[Datei:PVC200403P.JPG]]

Über die Pin-Heads JP8(JP6 oder JP7) und JP19 kann die parallele Steuerung des LCD-Moduls organisiert werden. In meinem Fall habe ich ein Display PVC200403P von PICVUE genommen. Das ist ein Hitachi HD44780 Standard- Display, und verfügt über 8–bit Daten-Bus + 3 Steuerung-Wires. Erlaubt ist auch die Datenübertragung über 4-bit Daten-Bus+3 Steuerung-Wires. D.h. benötigt werden mindestens 7 Adern des MCU + Stromversorgung. Im Beispiel 3 und 4 (Siehe Anhang "Videobeispiele"), habe ich mein Display mit insgesamt 8 Adern gesteuert(-,+ -Stromversorgung, E-Enable, RS-Register Select, 4-bit Datenbus). Alle anderen Eingänge wurden mit "-" verbunden. Diese Lösung spart Euch I/O, benötigt allerdings bisschen komplexere LCD-Initialisierung. Die im Datenblatt"PVC200403P" angegebene Zeitverzögerungen zwischen den Initialisierungsbefehlen habe ich mit Timer1 realisiert und damit die Abfrage des Busy-Flags gespart.

== ICSP Programmierung ==

''ICSP I/O Beschaltung'' [[Datei:ICSP.png]]

Ein ICSP I/O ermöglicht die interne Programmierung des Microcontrollers,
Z.b. via PicKit2 oder PicKit3. In meinem Fall habe ich ein EEPRom Programmiergerät mit ZIF-Socket zu ICSP Adapter genommen(Siehe Anhang).

[http://www.mikrocontroller.net/wikifiles/2/2f/ICSP_Programmierung.JPG EEPROM_Programmer + ICSP Adapter]

== Leiterplatte ==

''A4 Größe Design'' [[Datei:Brd Entwicklungsboard.png]]

Schaltplandesign und Leiterplattenentwurf wurde im Eagle realisiert. Der Prototyp wurde auf der doppelseitigen Leiterplatte gefräst und bestückt. Das MCU wurde im Sockel befestigt. Hiermit können die weitere Erweiterungen und MCU-Wechsel ohne Löten durchgeführt werden.
Der Spannungsregler wurde auf die Leiterplatte gelegt und übers Wärmeleitpad mit dem Lötzinn befestigt. Somit spielt die Plattenfläche auch die Rolle des Kühlkörpers.

[[Datei:7805T.JPG]]

== Praktische Anwendung ==

''Real Time Clock '' [[Datei:Realtime_Clock.BMP]]

Eine der möglichen Anwendungen der Entwicklungsplatine ist ein Real-Clock mit der Ausgabe auf dem LCD-Display (siehe Bild). Hiermit werden die Prinzipien der I2C-, Parallel Datenübertragung und der dynamischen Tastenabfrage geübt. In dem Fall benötigen wir ein HD44780 Modul, Mainboard- Modul und ein I2C Modul.
Die 4x4 Tastatur wird direkt an PortB des MCU angeschlossen. Die ersten 4 Bits sind als Ausgange konfiguriert und die letzten 4 Bits dienen als Eingange mit den inneren Pull-Up Widerständen. Die parallele Datenübertragung zwischen dem MCU und LCD-Modul erfolgt über Port D und Port E des Microcontrollers. Die beiden Peripherie – Bausteine PCF8574 und PCF8583 benötigen serielle Datenübertragung im I²C Mode mit Taktfrequenz <100kHz. Damit es nicht zu Kollisionen führt, haben die beiden Bausteine verschiedene Adressen. Achten Sie auch darauf, dass alle Bausteine der I²C Peripherie eigene Protokollspezifik haben. Z.B.:

''PCF8574_Read_Mode'' [[Datei:8574_Read_Mode.png]]

''PCF8574_Write_Mode'' [[Datei:8574 Write Mode.png]]

''PCF8583_Read_Mode'' [[Datei:Clock_Read_Mode.png]]

''PCF8583_Write_Mode'' [[Datei:Clock_Write_Mode.png]]

== Fazit ==
Der Einstieg in die moderne Mikroprozessor- und Mikrocontroller-welt ist praktisch ohne Evaluations-Kits nicht möglich. An manchen Stellen ist die Simulationsprogramm ungenau, insbesondere ist sehr von der Prozessorbelastung abhängig,und lässt die äußere Einflüsse nicht simulieren.In dem Fall ist der Einsatz der Entwicklungsplatine unvermeidlich. Mehrere auf dem Markt vorgestellte Platten sind wegen ihren hohen Preisen nicht an einen durchschnittlichen Käufer(Studenten oder Schüler) gedacht und beziehen sich auf den konkreten Mikroprozessor, der nicht auszutauschen ist. In diesem Zusammenhang , bietet die angebotene Entwicklungsplatine die Universalität, kann leicht nachgebaut und erweitert werden. Der IC-Sockel ermöglicht den unkomplizierten MCU-Tausch, Upgrade oder Übergang zu dem MCU anderer Hersteller.

== Kontakt ==
Nach Anfrage kann ich auch die Quellcode, sowie PCB-Design und Programmierbeispiele zur Verfügung stellen.
Ihre Fragen bitte an : maiierok@t-online.de

== Videobeispiele ==
''Video "Anwendung Real-Time Clock"''
[http://www.youtube.com/watch?v=9R3alJx_ldA Simulation im Proteus]

''Video "Versuch #1 LED& Buzzer- Steuerung"''
[http://youtu.be/Yn8-Ny-1He0 LED&Buzzer TEST#1 ]

''Beispiel 3 "Liebeserklärung''
[http://youtu.be/26qt7u2WQ8s Mainboard + HD44780]

''Beispiel 4 "Anschluß mit PC über USB''
[http://www.youtube.com/watch?v=nqvd8O5QHOQ Mainboard+ Comm-Board+ HD44780]

== Link ==

''PIC18 Datasheet'' [[Datei:Pic18f2420-2520-4420-4520.pdf]]

''A200_ua7805'' [[Datei:A200_ua7805.pdf]]

''PCF8583'' [[Datei:Clock and Calendar.pdf]]

''PCF8574'' [[Datei:PCF8574.pdf]]

''I²C_ Temperature Sensor'' [[Datei:Thermo_I²C.pdf]]

''Mcp23s17 SPI Expander'' [[Datei:Mcp23s17.pdf]]

''HD44780 Display'' [http://www.adafruit.com/datasheets/HD44780.pdf Datasheet]

P89626

2013-05-22T16:15:14Z

Mthomas: Schützte „P89626“: Weblink-Spam ([edit=autoconfirmed] (bis 22. Juni 2013, 16:15 Uhr (UTC)) [move=autoconfirmed] (bis 22. Juni 2013, 16:15 Uhr (UTC)))

Alles über den [http://www.medion.com/au/service/start/_product.php?msn=50039627 MEDION LIFE P89626 (MD 86407) NAS] den es im Dez.2011 bei Aldi-Süd für 99€ gab

Nummern von Medion: MD 86407 - MSN: 50039627

Desweiteren kann dies größtenteils auch auf den P89630 NAS von Medion angewandt werden, welcher lediglich eine größere Festplatte besitzt (2TB). Sämtliche andere Eigenschaften sind exakt gleich.

= Beitrag im Forum =

* [https://www.mikrocontroller.net/topic/240238 Alles rund um den MEDION LIFE P89626 NAS]
* [http://www.mikrocontroller.net/topic/187115#new 20Euro Embedded System mit ARM, 128MB RAM und 256MB Flash ]

extern:
* http://forum.nas-portal.org/forumdisplay.php?135-Medion
* http://forums.whirlpool.net.au/archive/1817691

= Unterseiten =

Es gibt noch eine Reihe Unterseiten:

* [[P89626/UART]] - Alles rund um die UART-Schnittstelle
* [[P89626/debootstrap]] - NAS mit Debian betreiben
* [[P89626/ArchLinuxARM]] - NAS mit ArchLinuxARM betreiben
* [[P89626/dropbear]] - SSH Server mit dropbear einrichten
* [[P89626/usb key func]] - In den Boot-Prozess reinhacken

(Alle Seiten sollten in der [http://www.mikrocontroller.net/articles/Kategorie:P89626 Kategorie "P89626"] sein!)

= Technische Daten =

* Dual Core ARM [http://www.plxtech.com/products/consumer/nas7820 PLX-NAS7820] 750 MHz ('''Achtung:''' Offizielle Firmware bis Version 1.01 nutzt nur einen CPU-Kern! Siehe [[P89626#Single_Core_Problem]])
* 128 MB RAM
* 1.50 TB (1.36 TiB) Seagate Barracuda Green ST1500DL003-9VT1 SATA-HD
* 2 x USB 2.0
* 1 x Gigabit LAN (Realtek RTL8211E)

Netzteil:
* Eingang: 100-240 V, 50/60 Hz, 0,4 A
* Ausgang: 12 V, 1,5 A Gleichspannung

== Single-Core-Problem ==

!Die aktuelle Firmware 1.02 nutzt nun beide Kerne der CPU!

In der Box steckt zwar ein Dual-Core, doch entgegen der Werbeaussage wird bei der aktuellen Firmware '''1.00(UZD.2)''' (''cat /zyxel/mnt/info/fwversion'') nur '''ein CPU-Kern genutzt!'''

Hier ein paar Indizien, die das belegen sollen (Bitte ergänzen):

Dateien/Unterverzeichnisse existieren in ''/sys/devices/system/cpu/'''cpu0''''', aber ''/sys/devices/system/cpu/'''cpu1''''' ist leer (siehe http://www.mikrocontroller.net/topic/240238?page=2#2448859 )

Außerdem, zeigt es der Inhalt dieser Dateien an (siehe http://www.mikrocontroller.net/topic/240238?goto=2469569#2469802 ):
<pre>/sys/devices/system/cpu/kernel_max -> 1
/sys/devices/system/cpu/offline -> 1
/sys/devices/system/cpu/online -> 0
/sys/devices/system/cpu/possible -> 0-1
/sys/devices/system/cpu/present -> 0-1</pre>

'''offline:''' cpus that are not online because they have been
HOTPLUGGED off or exceed the limit of cpus allowed by the
kernel configuration (kernel_max above).
Quelle: http://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu

Original-System zeit per [[#dmesg]]:
<pre>Brought up 1 CPUs
SMP: Total of 1 processors activated (299.00 BogoMIPS).</pre>
ArchLinuxARM zeigt das an:
<pre>[ 0.630000] Brought up 2 CPUs
[ 0.640000] SMP: Total of 2 processors activated (598.83 BogoMIPS).
</pre>

Wenn du das NAS P89626 oder P89630 hast, schreib Aldi an und mache sie auf das Problem aufmerksam. Vielleicht erstellt Medion dann eine neue Firmware, wobei sie z.Z. das Problem abstreiten (siehe: http://www.mikrocontroller.net/topic/240238?goto=2468866#2468866 )
Kontakt zu Aldi:
* https://www.aldi-sued.de/de/html/contact.php
* https://www.aldi-nord.de/kontakt_form.php

Anmerkung:
Das Sourcecode-Archiv ist der eindeutigste Hinweis, da hier eben der Startup des zweiten Kerns unterbunden worden ist.

hier die Infos zu den Stellen der Deaktivierung:
* http://www.mikrocontroller.net/topic/240238?goto=2470122#2470122
* http://www.mikrocontroller.net/topic/240238?goto=2470148#2470148

und hier das Ergebnis beim Entfernen dieser Zeilen.
* http://www.mikrocontroller.net/topic/240238?goto=2470241#2470241

== Festplattentemperatur ==

Die Box neigt mit ihrem lüfterlosen Design dazu, sich unter Last stark aufzuheizen. Forennutzer berichten von Festplattentemperaturen über 55°C (auslesbar mit smartmontools) [http://www.mikrocontroller.net/topic/240238#2443707]. Seagate spezifiziert für die Platte eine Betriebstemperatur bis 60°C und eine maximale Temperaturänderung im Betrieb von 20°C pro Stunde [http://www.seagate.com/ww/v/index.jsp?name=st1500dl003-bcuda-green-sata-6gb-1.5tb-hd&vgnextoid=2035439d45c0b210VgnVCM1000001a48090aRCRD&locale=en-US&pf=1#tTabContentSpecifications]. Um die Einhaltung dieser Vorgaben zu garantieren, bieten sich zwei Möglichkeiten an:
* Verwendung eines Lüfters mit externer Stromversorgung. Anbringung an Ober-/Unterseite des Gehäuses oder Montage eines Radiallüfters im Gehäuseinnern.
* Entfernen des schwarzen Kunststoffgehäuses (senkt die Temperatur der Festplatte unter Last auf etwa 40°C).

Eine Anleitung zur Lüftermontage findet sich in: [http://www.mikrocontroller.net/attachment/132515/Installation_ArchLinuxArm.pdf]

== Ähnliche Geräte ==

Systeme, die den gleichen SoC-"NAS 7820"-Prozessor nutzen:
* MEDION LIFE P89630 (MD 86587) (gleiche Box, nur mit 2-TB-Laufwerk)
* MEDION LIFE [[P89636]] (gleiche Box, nur mit 1-TB-Laufwerk)
* [http://archlinuxarm.org/platforms/armv6/pogoplug-provideov3 Pogoplug Pro/Video/v3]
* [http://iomega.nas-central.org/wiki/Category:Home_Media_CE Iomega Home Media Network Hard Drive, Cloud Edition]
** Open Source Paket: https://iomega-eu-en.custhelp.com/app/answers/detail/a_id/26776
* [http://www.heise.de/preisvergleich/692728 Level One GNS-1001]
** Firmware Download: http://www.level1.tw/level1/firmware/GNS-1001(GNS-1001_v3.6.6_HW-1)_2011-07-22.zip

= Demontage =

Die Demontage und das Wechseln der S-ATA-Festplatte sind sehr einfach für Schrauber möglich: Unter den Gummifußflächen sind zwei Schrauben zu lösen, dann kann man das Gehäuse aus zwei Schalen recht einfach auseinandernehmen. Festplatte und Elektronik sind mit weiteren zwei Schrauben vom Gehäusedeckel zu lösen. Festplatte ist mit drei Schrauben an dem Platinenteil befestigt. Alles ohne große Probleme zu lösen und wieder zusammenzubauen...

Bilder der Platine gibt es u.a. hier:
* http://flickr.com/photos/jensdiemer/tags/p89626/

sowie hier: [http://i41.tinypic.com/5leazs.jpg], [http://i43.tinypic.com/11qjvgh.jpg], [http://i44.tinypic.com/2nurcr8.jpg], [http://i42.tinypic.com/25tc576.jpg]

== cpuinfo ==
<pre>
~ # cat /proc/cpuinfo
Processor : ARMv6-compatible processor rev 5 (v6l)
processor : 0
BogoMIPS : 299.00

Features : swp half thumb fastmult edsp java
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xb02
CPU revision : 5

Hardware : Oxsemi NAS
Revision : 0000
Serial : 0000000000000000
</pre>

== /proc/modules ==
<pre>
ntfs 106132 0 - Live 0xbf015000
gmac 47336 0 - Live 0xbf004000
mii 6764 1 gmac, Live 0xbf000000
</pre>

== lsmod ==
<pre>
/ # lsmod
gmac 47336 0 - Live 0xbf004000
mii 6764 1 gmac, Live 0xbf000000
</pre>

== mtd ==
<pre>~ # cat /proc/mtd
dev: size erasesize name
mtd0: 08000000 00020000 "NAND 128MiB 3,3V 8-bit"
mtd1: 00040000 00020000 "stage1"
mtd2: 00380000 00020000 "uboot"
mtd3: 00080000 00020000 "uboot_env"
mtd4: 00a00000 00020000 "kernel"
mtd5: 00a00000 00020000 "etc"
mtd6: 00a00000 00020000 "info"
mtd7: 05dc0000 00020000 "sysdisk"
</pre>

Weitere Details dazu: http://www.mikrocontroller.net/topic/240238?goto=2471725#2471733

== Speicherinformationen ==

=== mount-Punkte ===
<pre>~ # mount
rootfs on / type rootfs (rw)
/proc on /proc type proc (rw,relatime)
/sys on /sys type sysfs (rw,relatime)
none on /proc/bus/usb type usbfs (rw,relatime)
devpts on /dev/pts type devpts (rw,relatime,mode=600)
/dev/mtdblock6 on /zyxel/mnt/info type yaffs2 (ro,relatime)
/dev/mtdblock7 on /zyxel/mnt/sysdisk type yaffs2 (ro,relatime)
/dev/loop0 on /ram_bin type ext2 (ro,relatime,errors=continue)
/dev/loop0 on /usr type ext2 (ro,relatime,errors=continue)
/dev/loop0 on /lib/security type ext2 (ro,relatime,errors=continue)
/dev/loop0 on /lib/modules type ext2 (ro,relatime,errors=continue)
/dev/ram0 on /tmp/tmpfs type tmpfs (rw,relatime,size=5120k)
/dev/ram0 on /usr/local/etc type tmpfs (rw,relatime,size=5120k)
/dev/ram0 on /usr/local/var type tmpfs (rw,relatime,size=5120k)
/dev/mtdblock5 on /etc/zyxel type yaffs2 (rw,relatime)
/dev/md4 on /i-data/6764ac2f type xfs (rw,relatime,nouuid,attr2,nobarrier,usrquota)
/dev/md4 on /usr/local/zy-pkgs type xfs (rw,relatime,nouuid,attr2,nobarrier,usrquota)
/dev/md4 on /etc/zyxel/zy-pkgs type xfs (rw,relatime,nouuid,attr2,nobarrier,usrquota)
/dev/md4 on /usr/local/apache/htdocs/adv,/pkg type xfs (rw,relatime,nouuid,attr2,nobarrier,usrquota)
/dev/md4 on /usr/local/apache/web_framework/data/cache type xfs (rw,relatime,nouuid,attr2,nobarrier,usrquota)
/dev/mtdblock5 on /usr/local/apache/web_framework/data/config type yaffs2 (rw,relatime)</pre>

=== Freier Plattenplatz ===
Ursprungszustand:
<pre>~ # df -h
Filesystem Size Used Available Use% Mounted on
/dev/mtdblock6 10.0M 804.0K 9.2M 8% /zyxel/mnt/info
/dev/mtdblock7 93.8M 86.8M 7.0M 93% /zyxel/mnt/sysdisk
/dev/loop0 83.3M 75.5M 7.8M 91% /ram_bin
/dev/loop0 83.3M 75.5M 7.8M 91% /usr
/dev/loop0 83.3M 75.5M 7.8M 91% /lib/security
/dev/loop0 83.3M 75.5M 7.8M 91% /lib/modules
/dev/ram0 5.0M 4.0K 5.0M 0% /tmp/tmpfs
/dev/ram0 5.0M 4.0K 5.0M 0% /usr/local/etc
/dev/ram0 5.0M 4.0K 5.0M 0% /usr/local/var
/dev/mtdblock5 10.0M 1.4M 8.6M 14% /etc/zyxel
/dev/md4 1.4T 519.0M 1.4T 0% /i-data/6764ac2f
/dev/md4 1.4T 519.0M 1.4T 0% /usr/local/zy-pkgs
/dev/md4 1.4T 519.0M 1.4T 0% /etc/zyxel/zy-pkgs
/dev/md4 1.4T 519.0M 1.4T 0% /usr/local/apache/htdocs/adv,/pkg
/dev/md4 1.4T 519.0M 1.4T 0% /usr/local/apache/web_framework/data/cache
/dev/mtdblock5 10.0M 1.4M 8.6M 14% /usr/local/apache/web_framework/data/config
</pre>

=== hdparm ===
hdparm (siehe http://www.mikrocontroller.net/topic/240238?page=2#2453618 ):
<pre>
...
Configuration:
Logical max current
cylinders 16383 16383
heads 16 16
sectors/track 63 63
--
CHS current addressable sectors: 16514064
LBA user addressable sectors: 268435455
LBA48 user addressable sectors: 2930277168
Logical Sector size: 512 bytes (*)
Physical Sector size: 4096 bytes (*)
Logical Sector-0 offset: 0 bytes
device size with M = 1024*1024: 1430799 MBytes
device size with M = 1000*1000: 1500301 MBytes (1500 GB)
cache/buffer size = unknown
Nominal Media Rotation Rate: 5900
...
</pre>

=== fdisk ===
<pre>/ # fdisk /dev/sda -l

Disk /dev/sda: 1500.3 GB, 1500301910016 bytes
255 heads, 63 sectors/track, 182401 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Device Boot Start End Blocks Id System
/dev/sda1 1 64 514048+ 83 Linux
/dev/sda2 65 182401 1464621952+ 9 AIX bootable

~ # fdisk -lu /dev/sda

Disk /dev/sda: 2000.3 GB, 2000398934016 bytes
255 heads, 63 sectors/track, 243201 cylinders, total 3907029168 sectors
Units = sectors of 1 * 512 = 512 bytes

Device Boot Start End Blocks Id System
/dev/sda1 63 1028159 514048+ 83 Linux
/dev/sda2 1028160 3907024064 1952997952+ 9 AIX bootable
</pre>

== uBoot ==

=== uBoot help ===
<pre>$ help
? - alias for 'help'
base - print or set address offset
bdinfo - print Board Info structure
bootm - boot application image from memory
bootp - boot image via network using BootP/TFTP protocol
cmp - memory compare
cp - memory copy
crc32 - checksum calculation
echo - echo args to console
exit - exit script
go - start application at address 'addr'
help - print online help
iminfo - print header information for application image
ledfail - Extinguish (0) or light (1) failure LED
loop - infinite loop on address range
md - memory display
mm - memory modify (auto-incrementing)
mtest - simple RAM test
mw - memory write (fill)
nand - NAND sub-system
nboot - boot from NAND device
nm - memory modify (constant address)
nwboot - NAND Write boot information
ping - send ICMP ECHO_REQUEST to network host
printenv- print environment variables
rarpboot- boot image via network using RARP/TFTP protocol
reset - Perform RESET of the CPU
run - run commands in an environment variable
saveenv - save environment variables to persistent storage
setenv - set environment variables
test - minimal test like /bin/sh
tftpboot- boot image via network using TFTP protocol
version - print monitor version
</pre>

=== uBoot-boot-Ausgaben ===

Ausgaben über UART (mehr Info dazu auf [[P89626/UART]]), bis Ausgaben per dmesg einsehbar sind:
<pre>
Stage-1 Bootloader Tue Aug 9 16:44:00 CST 2011
Attempting to set PLLA to 750MHz ...
plla_ctrl0 : 0x0000000A
plla_ctrl1 : 0x000F0000
plla_ctrl2 : 0x001D01A0
plla_ctrl3 : 0x00000017
PLLA Set

Setup memory, testing
Reading NAND, Image 0
Hdr len: 0x0001A94C
Hdr CRC: 0xF0019DAC
OK

U-Boot 1.1.2 (Jun 24 2011 - 09:41:57)

U-Boot code: 60D00000 -> 60D1A94C BSS: -> 60D1F004
RAM Configuration:
Bank #0: 60000000 128 MB
SRAM Configuration:
64KB at 0x50000000
NAND:128 MiB
In: serial
Out: serial
Err: serial
Setting Linux mem= boot arg value
Hit any key to stop autoboot: 0

Loading from device 0: 128MiB 3,3V 8-bit (offset 0x440000)
Image Name: Linux-2.6.31.14_SMP_820
Image Type: ARM Linux Kernel Image (uncompressed)
Data Size: 5241420 Bytes = 5 MB
Load Address: 60008000
Entry Point: 60008000
## Booting image at 61000000 ...
Image Name: Linux-2.6.31.14_SMP_820
Image Type: ARM Linux Kernel Image (uncompressed)
Data Size: 5241420 Bytes = 5 MB
Load Address: 60008000
Entry Point: 60008000
Verifying Checksum ... OK
OK

Starting kernel ...

Uncompressing Linux... .......................... ... done, booting the kernel.
Linux version 2.6.31.14_SMP_820 (root@Neo) (gcc version 4.3.2 (crosstool-NG-1.8.0) ) #2 SMP Wed Oct 5 21:54:14 CST 2011
...
</pre>

== dmesg ==
<pre>
~ # dmesg
Linux version 2.6.31.14_SMP_820 (root@Neo) (gcc version 4.3.2 (crosstool-NG-1.8.0) ) #2 SMP Wed Oct 5 21:54:14 CST 2011
CPU: ARMv6-compatible processor [410fb025] revision 5 (ARMv7), cr=00c5387f
CPU: VIPT nonaliasing data cache, VIPT nonaliasing instruction cache
Machine: Oxsemi NAS
1 memory region
Ignoring unrecognised tag 0x00000000
Memory policy: ECC disabled, Data cache writealloc
On node 0 totalpages: 32768
free_area_init_node: node 0, pgdat c07be3a0, node_mem_map c07e6000
Normal zone: 256 pages used for memmap
Normal zone: 0 pages reserved
Normal zone: 32512 pages, LIFO batch:7
Built 1 zonelists in Zone order, mobility grouping on. Total pages: 32512
Kernel command line: console=ttyS0,115200 elevator=cfq mac_adr=0x00,0x30,0xe0,0x00,0x00,0x01 mem=128M poweroutage=yes
PID hash table entries: 512 (order: 9, 2048 bytes)
Dentry cache hash table entries: 16384 (order: 4, 65536 bytes)
Inode-cache hash table entries: 8192 (order: 3, 32768 bytes)
Memory: 128MB = 128MB total
Memory: 121656KB available (5340K code, 338K data, 2264K init, 0K highmem)
Hierarchical RCU implementation.
NR_IRQS:96
OX820_RPS_init_irq: interrupts 64 to 96
ox820_clocksource_init() Timer 2 running at 390625 Hz
Console: colour dummy device 80x30
console [ttyS0] enabled
Calibrating delay loop... 299.00 BogoMIPS (lpj=1495040)
Mount-cache hash table entries: 512
CPU: Testing write buffer coherency: ok
Calibrating local timer... 374.49MHz.
Brought up 1 CPUs
SMP: Total of 1 processors activated (299.00 BogoMIPS).
NET: Registered protocol family 16
Number of DMA channels = 4, version = 4
Allocating 303 SRAM generic DMA descriptors
bio: create slab <bio-0> at 0
SCSI subsystem initialized
libata version 3.00 loaded.
usbcore: registered new interface driver usbfs
usbcore: registered new interface driver hub
usbcore: registered new device driver usb
NET: Registered protocol family 2
IP route cache hash table entries: 1024 (order: 0, 4096 bytes)
Switched to NOHz mode on CPU #0
TCP established hash table entries: 4096 (order: 3, 32768 bytes)
TCP bind hash table entries: 4096 (order: 3, 32768 bytes)
TCP: Hash tables configured (established 4096 bind 4096)
TCP reno registered
NET: Registered protocol family 1
Create fragment cache
MitraStar NAS GPIO driver/controller 1.00
Initialize LEDs
o SYS LED
o COPY LED
o Quota 4 LED
Initialize buzzer
Initialize buttons
o Copy Button
o Reset Button
nas_gpio: Register a char device 254:0
audit: initializing netlink socket (disabled)
type=2000 audit(0.880:1): initialized
VFS: Disk quotas dquot_6.5.2
Dquot-cache hash table entries: 1024 (order 0, 4096 bytes)
Installing knfsd (copyright (C) 1996 okir@monad.swb.de).
fuse init (API version 7.12)
SGI XFS with security attributes, large block/inode numbers, no debug enabled
SGI XFS Quota Management subsystem
yaffs built Oct 5 2011 21:42:41 Installing.

YAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.

msgmni has been set to 237
alg: No test for stdrng (krng)
io scheduler noop registered
io scheduler anticipatory registered
io scheduler deadline registered
io scheduler cfq registered (default)
Serial: 8250/16550 driver, 2 ports, IRQ sharing disabled
serial8250: ttyS0 at MMIO 0x44200000 (irq = 55) is a 16550A
brd: module loaded
loop: module loaded
ox820sata: OX820 sata core.
scsi0 : oxnassata
scsi1 : oxnassata
ata1: SATA max UDMA/133 irq 50
ata2: SATA max UDMA/133 irq 50
ata1: SATA link up 1.5 Gbps (SStatus 113 SControl 300)
ox820sata_qc_issue: Core busy, returning an error.
ata1.00: failed to IDENTIFY (I/O error, err_mask=0x100)
ata1: SATA link up 1.5 Gbps (SStatus 113 SControl 300)
ox820sata_qc_issue: Core busy, returning an error.
ata1.00: failed to IDENTIFY (I/O error, err_mask=0x100)
ata1: limiting SATA link speed to 1.5 Gbps
ata1: SATA link up 1.5 Gbps (SStatus 113 SControl 310)
ox820sata_qc_issue: Core busy, returning an error.
ata1.00: failed to IDENTIFY (I/O error, err_mask=0x100)
ata1: SATA link up 1.5 Gbps (SStatus 113 SControl 310)
ata1: exception Emask 0x10 SAct 0x0 SErr 0x0 action 0x9 t4
ata1: hard resetting link
ata1: SATA link up 1.5 Gbps (SStatus 113 SControl 300)
ata1.00: ATA-8: ST1500DL003-9VT16L, CC4A, max UDMA/133
ata1.00: 2930277168 sectors, multi 0: LBA48 NCQ (depth 0/32)
ata1.00: configured for UDMA/133
ata1: exception Emask 0x10 SAct 0x0 SErr 0x0 action 0x9 t3
ata1.00: configured for UDMA/133
ata1: EH complete
ata2: SATA link down (SStatus 0 SControl 300)
scsi 0:0:0:0: Direct-Access ATA ST1500DL003-9VT1 CC4A PQ: 0 ANSI: 5
sd 0:0:0:0: [sda] 2930277168 512-byte logical blocks: (1.50 TB/1.36 TiB)
sd 0:0:0:0: [sda] 4096-byte physical blocks
sd 0:0:0:0: [sda] Write Protect is off
sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
sda:
sd 0:0:0:0: Attached scsi generic sg0 type 0
sda1 sda2
PPP generic driver version 2.4.2
PPP Deflate Compression module registered
PPP BSD Compression module registered
sd 0:0:0:0: [sda] Attached SCSI disk
PPP MPPE Compression module registered
NET: Registered protocol family 24
PPPoL2TP kernel driver, V1.0
NAND device: Manufacturer ID: 0xad, Chip ID: 0xf1 (Hynix NAND 128MiB 3,3V 8-bit)
Scanning device for bad blocks
Bad eraseblock 17 at 0x000000220000
Bad eraseblock 282 at 0x000002340000
Creating 7 MTD partitions on "NAND 128MiB 3,3V 8-bit":
0x000000000000-0x000000040000 : "stage1"
0x000000040000-0x0000003c0000 : "uboot"
0x0000003c0000-0x000000440000 : "uboot_env"
0x000000440000-0x000000e40000 : "kernel"
0x000000e40000-0x000001840000 : "etc"
0x000001840000-0x000002240000 : "info"
0x000002240000-0x000008000000 : "sysdisk"
ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
Start USB clocks
oxnas-ehci oxnas-ehci.0: OXNAS EHCI Host Controller
oxnas-ehci oxnas-ehci.0: new USB bus registered, assigned bus number 1
oxnas-ehci oxnas-ehci.0: irq 39, io mem 0x00000000
oxnas-ehci oxnas-ehci.0: USB 0.0 started, EHCI 1.00
usb usb1: configuration #1 chosen from 1 choice
hub 1-0:1.0: USB hub found
hub 1-0:1.0: 2 ports detected
usbcore: registered new interface driver usblp
Initializing USB Mass Storage driver...
usbcore: registered new interface driver usb-storage
USB Mass Storage support registered.
usbcore: registered new interface driver ums-datafab
usbcore: registered new interface driver ums-freecom
usbcore: registered new interface driver ums-isd200
usbcore: registered new interface driver ums-jumpshot
usbcore: registered new interface driver ums-sddr09
usbcore: registered new interface driver ums-sddr55
usbcore: registered new interface driver ums-usbat
mice: PS/2 mouse device common for all mice
md: linear personality registered for level -1
md: raid0 personality registered for level 0
md: raid1 personality registered for level 1
usbcore: registered new interface driver hiddev
usbcore: registered new interface driver usbhid
usbhid: v2.6:USB HID core driver
TCP cubic registered
NET: Registered protocol family 10
NET: Registered protocol family 17
RPC: Registered udp transport module.
RPC: Registered tcp transport module.
registered taskstats version 1
Freeing init memory: 2264K
Probing for Synopsis GMAC, unit 0
eth0: Tuning GMAC 0 RGMII timings
eth0: PHY is Realtek RTL8211E, type 0x001cc915
eth0: Disable EEE (Energy Efficient Ethernet 802.3az)
eth0: Set SSC
eth0: GMAC ver = 53, vendor ver = 18 at 0xed400000, IRQ 40
eth0: Found PHY at address 7, type 0x001cc915 -> 10/100/1000
eth0: Ethernet addr: 00:30:e0:00:00:00
probe() eth0: Leon x2 clock
hw_set_mac_address() Storing port0 mac_adr in global array
CoPro offload is active on egiga0
Alloc'ing ARM descs 8192 bytes
Alloc'ing CoPro parameters 40 bytes
gmac gmac.0: firmware: requesting gmac_copro_firmware
CoPro: Programming start address as 0xd000e000
egiga0: Resetting GMAC
egiga0: GMAC reset complete
workaround step1
workaround step2
workaround finish
hw_set_mac_address() Storing port0 mac_adr in global array
egiga0: Setting Rx flow control thresholds for LAN port
CoPro available SRAM end 0x00000001
Copro offload started
Waiting for auto-negotiation to complete
Waiting for auto-negotiation to complete
egiga0: PHY is Realtek RTL8211E, type 0x001cc915
egiga0: Disable EEE (Energy Efficient Ethernet 802.3az)
egiga0: Set SSC
egiga0: link down
egiga0: link up, 100Mbps, full-duplex, using pause, lpa 0x45E1
yaffs: dev is 32505862 name is "mtdblock6" ro
yaffs: passed flags ""
yaffs: Attempting MTD mount of 31.6,"mtdblock6"
uncorrectable error :
yaffs_read_super: isCheckpointed 0
yaffs: dev is 32505863 name is "mtdblock7" ro
yaffs: passed flags ""
yaffs: Attempting MTD mount of 31.7,"mtdblock7"
block 9 is bad
yaffs_read_super: isCheckpointed 0
REISERFS warning (device sda1): super-6502 reiserfs_getopt: unknown mount option "iocharset=utf8"
FAT: utf8 is not a recommended IO charset for FAT filesystems, filesystem will be case sensitive!
hfs: unable to parse mount options
udf: bad mount option "shortname=mixed" or missing value
XFS: unknown mount option [iocharset].
yaffs: dev is 8388609 name is "sda1" ro
yaffs: passed flags "iocharset=utf8,shortname=mixed"
yaffs: Bad mount option "iocharset=utf8"
yaffs: dev is 8388609 name is "sda1" ro
yaffs: passed flags "iocharset=utf8,shortname=mixed"
yaffs: Bad mount option "iocharset=utf8"
REISERFS warning (device sda1): super-6502 reiserfs_getopt: unknown mount option "iocharset=utf8"
FAT: utf8 is not a recommended IO charset for FAT filesystems, filesystem will be case sensitive!
hfs: unable to parse mount options
udf: bad mount option "shortname=mixed" or missing value
XFS: unknown mount option [iocharset].
yaffs: dev is 8388609 name is "sda1" ro
yaffs: passed flags "iocharset=utf8,shortname=mixed"
yaffs: Bad mount option "iocharset=utf8"
yaffs: dev is 8388609 name is "sda1" ro
yaffs: passed flags "iocharset=utf8,shortname=mixed"
yaffs: Bad mount option "iocharset=utf8"
yaffs: dev is 32505861 name is "mtdblock5" rw
yaffs: passed flags ""
yaffs: Attempting MTD mount of 31.5,"mtdblock5"
yaffs: restored from checkpoint
yaffs_read_super: isCheckpointed 1
NTFS driver 2.1.29 [Flags: R/O MODULE].
egiga0: no IPv6 routers present
md: md4 stopped.
md: bind<sda2>
raid1: raid set md4 active with 1 out of 2 mirrors
md4 using HW RAID-1
HW-RAID1 sda2, is read/write.
HW-RAID1 using disk sda2 on port 0 mirror 0
md4: detected capacity change from 0 to 1499772813312
md4: unknown partition table
Filesystem "md4": Disabling barriers, trial barrier write failed
XFS mounting filesystem md4
Starting XFS recovery on filesystem: md4 (logdev: internal)
Ending XFS recovery on filesystem: md4 (logdev: internal)
Adding 524280k swap on /i-data/.system/swap_ul6545p. Priority:-1 extents:1 across:524280k
</pre>

= Software =

Installiert ist die Firmware '''1.00(UZD.2)'''. Sie basiert offensichtlich auf der Firmware vom '''Zyxel NSA-210''':

<pre>~ # cat /zyxel/mnt/info/fwversion
1.00(UZD.2)
~ # cat /zyxel/mnt/info/modelid
AB03
~ # cat /zyxel/mnt/info/revision
32694
~ # zysh --version
zysh: version 2.0.0
Build: 21:37:19 Oct 5 2011
# cat /etc/Zy_Private
52103jeenajevol8290i
</pre>

''modelid'' '''AB03''' steht für '''STG212''' (siehe /etc/init.d/rcS)

* Linux nas-server 2.6.31.14_SMP_820 #2 SMP Wed Oct 5 21:54:14 CST 2011 armv6l GNU/Linux
* cat /proc/version: Linux version 2.6.31.14_SMP_820 (root@Neo) (gcc version 4.3.2 (crosstool-NG-1.8.0) ) #2 SMP Wed Oct 5 21:54:14 CST 2011
* BusyBox v1.17.2

== Paketverwaltung ==
Pakete und Updates der Firmware werden von '''download.medion.de''' gezogen. Genauen Link zu Firmware erhält man mit '''cat /etc/firmware_src_url'''

Pakete werden per '''ipkg v0.99.163''' (/usr/bin/ipkg-cl) installiert und landen auf der Festplatte unter '''/i-data/md0/admin/package/''' Dies ist anscheinend in der Datei '''/etc/zyxel/zy-pkg.conf''' festgelegt.

<pre>
~ # ipkg-cl print_architecture
arch all 1
arch noarch 1
arch arm 10
</pre>

== Konfiguration ==

Die meiste Konfigurationen (u.a. Name des NAS, existierende User und Freigaben) findet hier wieder:
* '''/etc/zyxel/conf/startup-config.conf'''

== environment ==
<pre>/ # env
USER=root
LD_LIBRARY_PATH=/usr/local/zy-pkgs/lib
OLDPWD=/usr/local/apache/cgi-bin
HOME=/root
LOGNAME=root
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/zyxel/sbin:/usr/local/zy-pkgs/bin:/zyxel/htp
SHELL=/bin/sh
PWD=/
</pre>

== uboot env ==
<pre>/ # fw_printenv
bootargs= console=ttyS0,115200 elevator=cfq mac_adr=0x00,0x30,0xe0,0x00,0x00,0x01
bootcmd=run boot_nand
bootdelay=2
baudrate=115200
ipaddr=192.168.50.100
serverip=192.168.50.59
autoload=n
netmask=255.255.0.0
bootfile="uImage"
load_nand=nboot 61000000 0 440000
boot=bootm 61000000
boot_nand=run load_nand boot
MODEL_ID=AB03
PRODUCT_NAME=STG-212
VENDOR_NAME=MitraStar Technology Corp.
ethaddr=00:11:41:xx:xx:xx
</pre>

== interessante Dateien/Pfade ==

NAS Speicher:
* '''/i-data/md0/'''
** '''/i-data/md0/public'''
** '''/i-data/md0/photo'''
** '''/i-data/md0/music'''
** usw.

Allgemeine Konfiguration:
* /etc/init.d/rcS - System-Start-Skript
* '''/usr/local/btn/''' Spezielle Steuerungs-Skripte

'''Apache:'''
* /etc/service_conf/httpd.conf
* /etc/service_conf/httpd_zld.conf
* /etc/service_conf/httpd_special.conf
* /usr/local/apache/htdocs
* /usr/local/apache/cgi-bin

= Aufspüren =

Die Box bezieht sich vom vorhandenen DHCP Server eine IP. Meldet sich mit dem Namen '''nas-server'''. Somit sollte ein '''ping nas-server''' gehen und die IP ausspucken.

Zum Aufspüren kann man auch nmap benutzten. z.B. das ganze Subnetz scannen:

<pre>~$ sudo nmap -e eth1 -sP 169.254.xxx.0/24</pre>

= Dienste =

Auf der Box laufen einige Dienste im Ursprungszustand:
<pre>~$ nmap -sT nas-server

PORT STATE SERVICE
21/tcp open ftp
80/tcp open http
139/tcp open netbios-ssn
443/tcp open https
631/tcp open ipp
3689/tcp open rendezvous
8082/tcp open blackice-alerts
9001/tcp open tor-orport
</pre>

Dienste:
* Port 21 - '''pure-ftpd v1.0.21'''
* Port 80 und 8082 - '''Apache/2.2.9 (Unix) mod_ssl/2.2.9 OpenSSL/0.9.8o mod_wsgi/2.4 Python/2.6.2'''
* Port 139 - '''Samba v3.0.32'''
* Port 3689 - '''mt-daapd: 0.2.4.2'''
* Port 9001 - DLNA-Server '''Twonky Media 5.1.13'''

= Einfacher Web Server =
Html-Dateien, die man im Verzeichnis <pre>/usr/local/apache/htdocs/adv,/pkg</pre> ablegt, können im Browser über <pre>http://nas-server/r32694,/adv,/pkg/</pre> angezeigt werden. Geht auch secure mit https. Mit entsprechender Port-Freigabe kann man zumindest eine statische Website aufbauen.

seit FW-Version 1.01 lautet der Link
http://nas-server/r34814,/adv,/pkg/

Die Verzeichnisse unter <pre>/usr/local/apache</pre> scheinen im nicht beschreibbaren Bereich zu liegen. <pre>/usr/local/apache/htdocs/adv,/pkg</pre> ist auf einen beschreibbaren Bereich gemappt.

= Zugang =

Wie bei vielen NAS läuft auch hier ein WebServer. Es gibt den Benutzer '''admin''' mit Passwort '''1234''', mit dem man sich anmelden kann.

== Telnet ==

Telnet kann man mit dieser URL starten (wichtig ist, dass man sich vorher normal angemldet hat!):

<pre>http://nas-server/r32694,/adv,/cgi-bin/remote_help-cgi?type=backdoor</pre>

bzw.:

<pre>http://192.168.xxx.yyy/r32694,/adv,/cgi-bin/remote_help-cgi?type=backdoor</pre>

seit FW-Version 1.01 lautet der Link

<pre>http://nas-server/r34814,/adv,/cgi-bin/remote_help-cgi?type=backdoor</pre>

bzw.

<pre>http://192.168.xxx.yyy/r34814,/adv,/cgi-bin/remote_help-cgi?type=backdoor</pre>

Für FW 1.01(UZD.2) lautet der Link: ...r36258...

Per Telnet kann man sich mit '''root''' Passwort '''1234''' (bzw. das Passwort vom User '''admin''') verbinden.

Nach einem Reboot ist Telnet allerdings wieder aus!

Für das Starten von Telnet sind diese Dateien zuständig:
* /usr/local/apache/cgi-bin/remote_help-cgi
* /usr/local/btn/open_back_door.sh

=== Telnet-Zugang dauerhaft aktivieren ===

Eine Möglichkeit, den Telnet-Zugang bei jedem Booten des NAS automatisch zu starten, ist, ein neues Start-Skript anzulegen, z.B. so:

<pre>echo "/usr/local/btn/open_back_door.sh" > /usr/local/zy-pkgs/etc/init.d/starttelnet.sh
chmod +x /usr/local/zy-pkgs/etc/init.d/starttelnet.sh
</pre>

Siehe: http://www.mikrocontroller.net/topic/240238?goto=2457264#2457390

== SSH-Server aktivieren ==

Es ist möglich, einen SSH-Server mit "dropbear" zu realisieren und direkt nach dem Booten zu starten. Siehe Beschreibung auf http://www.mikrocontroller.net/articles/P89626/dropbear

= Dateien editieren =

Auf der Box gibt es VI als Editor. Möchte man Dateien bequemer editieren, kann man dies über '''SMB''', '''FTP''' oder '''NFS''' erledigen.

Einige Konfigurationsdateien scheinen eh auf der Platte im versteckten Verzeichnis '''.system''' gespeichert zu sein (z.B. '''.system/zy-pkgs/etc/exports''') Wenn man '''/i-data/6764ac2f/''' von außen erreichbar macht, kann man diese Dateien bequem editieren.

Eine Lösung wäre es, Dateien temporär in einen Share kopieren und wieder zurück, z.B.:

<pre>cp /etc/exports /i-data/6764ac2f/admin/</pre>
auf Client editieren und zurück:
<pre>cp /i-data/6764ac2f/admin/exports /etc/exports</pre>

Eine andere Lösung wäre, via telnet im admin share mit ln -s ../.system/ einen softlink auf das schreibbare Systemverzeichnis zu setzen, dann kann man das verzeichnis aus dem Samba-Share direkt erreichen.

= NFS =

Einen NFS-Server kann man über die Web-Oberfläche unter Admin/Applications/Package nachinstallieren.

Leider kann man über die Web-Oberfläche nur Exporte unterhalb von '''/i-data/6764ac2f/nfs/''' freigeben. Jedoch liegt die Datei '''/etc/exports''' im beschreibbaren Bereich. Somit kann man sie nach Belieben anpassen, ohne daß es beim Neustart "zurückgesetzt" wird.

In der '''/etc/exports''' z.B. das eintragen:
<pre>/i-data/6764ac2f/ 192.168.1.0/24(rw,sync,no_subtree_check,wdelay,no_root_squash)</pre>

Mounten geht das z.B. so:
<pre>~$ sudo mkdir /media/nas-server
~$ sudo mount 192.168.xxx.yyy:/i-data/6764ac2f/ /media/nas-server</pre>

(IP-Bereich natürlich anpassen)

= Backup des Flashspeichers =

Mit diesen Skripten kann man den Flash-Speicher sichern. Dazu die Skripte z.B. im admin-share speichern und per Telnet ausführen.

Ruft man das Skript ein weiteres Mal auf, werden die MD5-Daten angezeigt.

Welcher mtd-Teil was speichert, erfährt man durch ein '''cat /proc/mtd''' ([http://www.mikrocontroller.net/articles/P89626#mtd siehe oben])

== raw dd ==
Sicherung mittels dd.

Zu beachten ist:
<pre>To create an image of mtd0, you need to dump the nand without ecc. using
"dd if=/dev/mtd0 of=mtd0.DOESNOTWORK" will automatically do ecc for you
and will result in a corrupt image.</pre>

(Hinweis von http://jeff.doozan.com/debian/uboot/build_uboot.htm unter "Backup
/dev/mtd0")

<pre>
#!/bin/sh

dest=/i-data/6764ac2f/admin

for mtd in `cd /dev && ls mtd?`
do
echo "____________________________________________________________________"
echo "Backup von ${mtd}"
outfile=${dest}/${mtd}.img
if [ -f ${outfile} ]; then
echo "Skip backup, outfile ${outfile} exist!"
if [ -f ${outfile}.md5 ]; then
echo "MD5 info:"
(
set -x
cat ${outfile}.md5
md5sum ${outfile}
md5sum /dev/${mtd}
)
fi
else
(
set -x
dd if=/dev/${mtd} of=${outfile}
)
if [ $? == 0 ]; then
(
set -x
md5sum ${outfile} > ${outfile}.md5
cat ${outfile}.md5
)
fi

fi
done
</pre>

== nanddump ==
Hier ein Script, welches nanddump von Jeff Doozan benutzt (siehe: http://jeff.doozan.com/debian/uboot/build_uboot.htm )
<pre>
#!/bin/sh

dest=/i-data/6764ac2f/admin

if [ -f nanddump ]; then
echo "nanddump found, ok."
else
(
set -x
wget http://jeff.doozan.com/debian/uboot/nanddump
chmod +x nanddump
)
fi

for mtd in `cd /dev && ls mtd?`
do
echo "____________________________________________________________________"

mtd_info=`cat /proc/mtd | grep ${mtd}`

if [ -z "${mtd_info}" ]; then
echo "Skip ${mtd} because it's not in /proc/mtd"
else
echo "Backup ${mtd_info}"

prefix=${dest}/${mtd}
backup=${prefix}.backup
oob=${backup}.oob

if [ -f ${backup} ]; then
echo "Skip backup: File ${backup} exist!"
(
set -x
cat ${backup}.md5
md5sum ${backup}

cat ${oob}.md5
md5sum ${oob}
)
else
(
set -x
./nanddump -nof ${backup} /dev/${mtd}
md5sum ${backup} > ${backup}.md5
cat ${backup}.md5

./nanddump -nf ${oob} /dev/${mtd}
md5sum ${oob} > ${oob}.md5
cat ${oob}.md5
)
fi
fi
done
</pre>

= Cross-Compiler =
==crosstool-ng==
Auf dem Medion-Server ist die Original-Cross-Compiler-Umgebung für das NAS verfügbar. Mit der folgenden Anleitung wird die Toolchain unter Ubuntu 11.10 nach /opt installiert:

wget -c download2.medion.com/downloads/software/gpl_source_md86407.exe
wine gpl_source_md86407.exe
cd ~/.wine/drive_c/Medion/
tar -xvf x-tools.armv5v6.tar.gz
sudo mv x-tools /opt
export CC=/opt/x-tools/armv6_le/arm-none-linux-gnueabi/bin/arm-none-linux-gnueabi-gcc

'''hello.c''':
<c>#include <stdio.h>

int main(void)
{
printf("Hello world\n");
return 0;
}
</c>

arm-none-linux-gnueabi-gcc -Wall -g -o hello hello-c

==ELDK==
Da das ELDK nicht immer lauffähige Binaries erzeugt, sollte die crosstool-ng Toolchain eingesetzt werden.

(von http://www.mikrocontroller.net/topic/240238?goto=2446372#2442210 )

hier eine kleine Anleitung zur Installation eines Cross-Compilers unter
Ubuntu 10.04/11.10:

<pre>
$ sudo aptitude install ia32-libs # Nur für 64-Bit-Systeme
$ sudo mkdir /opt/eldk42
$ wget http://ftp.denx.de/pub/eldk/4.2/arm-linux-x86/iso/arm-2008-11-24.iso
$ sudo mount -t iso9660 -o loop -o exec arm-2008-11-24.iso /mnt
$ cd /mnt
$ sudo ./install -d /opt/eldk42/ armVFP
</pre>

<pre>$ /opt/eldk42/usr/bin/armVFP-linux-gcc -Wall -g -o hello hello.c</pre>

'''.bashrc'''
<pre>
# ELDK 4.2 ARM 11 (i.MX35)
export ARCH=armVFP
export CROSS_COMPILE=armVFP-linux-
export CC=armVFP-linux-gcc
export PATH=$PATH:/opt/eldk42/usr/bin:/opt/eldk42/bin
export ROOT=/opt/eldk42/armVFP/
</pre>

Beispiel dropbear compilieren:
<pre>
wget http://matt.ucc.asn.au/dropbear/dropbear-2011.54.tar.gz
tar -xvf dropbear-2011.54.tar.gz
cd dropbear-2011.54/
./configure --host=arm-linux
make
</pre>

= SATA Boot =

PLX7820-basierte Geräte können von SATA, SPI und NAND booten. Das SATA-Interface ist - dem Verwendungszweck des SoC entsprechend - immer vorhanden. Die beiden anderen Interfaces sind nicht in jedem Gerät implementiert. Die angegebene Reihenfolge stellt gleichzeitig die Priorität dar, mit der an den einzelnen Interfaces nach dem Bootloader gesucht wird.

Deshalb ist es möglich, durch spezielles Präparieren der angeschlossenen Festplatte von dieser zu booten. Der Inhalt des NAND braucht dafür nicht verändert zu werden. Nach Überschreiben der entsprechenden Stellen auf der Festplatte erfolgt der Boot-Vorgang wieder von NAND, wie in der Ausgangskonfiguration.

Die ersten 32 MB einer bootfähigen Festplatte können nicht für Partitionen genutzt werden, sondern enthalten folgende Daten (basiert auf [http://iomega.nas-central.org/wiki/Stock_Configuration_%28Home_Media_CE%29#.27Unused_space.27_.28first_32_MiB.29 der Tabbelle von iomega.nas-central.org]):

{| border="1"
|- style="background:#BBBBBB; color:black"
|Startblock (Blockgröße: 512 Bytes)||Größe (Bytes)||Inhalt||Kommentar
|-
|0||512||MBR||Die ersten 446 Bytes enthalten eine Art ''Startsequenz'', in der unter anderem die Nummer des Startblocks des Stage-1-Bootloaders vorkommt (siehe [http://www.mikrocontroller.net/topic/240238?goto=2486646#2477637 forum] und [https://de.wikipedia.org/wiki/Master_Boot_Record#Aufbau_des_MBR Wikipedia]). Danach folgt die MBR-Partitionstabelle.
|-
|1||1536||GUID-Partitionstabelle||
|-
|34||8736||Stage-1-Bootloader||
|-
|154||103552||U-Boot||
|-
|558||At least 608||U-Boot environment||
|-
|1290||2189216||uImage kernel||
|-
|16674||2787216||uImage initrd||
|-
|57080||5||0x69 0xD3 0xAB 0x52 0x31||Dies stellt möglicherweise eine Seriennummer dar. Die MAC-Adresse ist es nicht.
|-
|57088||4640||Stage-1-Bootloader||Kopie
|-
|57208||103568||U-Boot||Kopie
|-
|58344||2189216||uImage kernel||Kopie
|}

= Twonky Media Server: Versteckte Konfigurationsseite =

Der eingebaute Twonky Media Server hat eine versteckte Konfigurationsseite: http://nas-server:9001/config

Dort kann z.B. den Typen des Media-Receivers (TV) einstellen, um Videos zuverlässiger, mit mehr unterstützten Formaten abzuspielen.

Dazu einfach in der Liste der Media Receivers den Fernseher von "Generic Media Receiver" auf z.B. "Samsung TV" stellen.

Leider ist kein Knopf zum Speichern sichtbar. Dazu besser auf http://nas-server:9001/configpage/config-content.html gehen, da sind dann ganz oben Knöpfe zum Speichern etc.

= Links =

* http://forums.whirlpool.net.au/archive/1817691
* http://zyxel.nas-central.org/wiki/Category:NSA-212
* http://zyxel.nas-central.org/wiki/NZBGet
* http://zyxel.nas-central.org/wiki/SABnzdb

Test der 2TB Version
* http://www.heise.de/ct/artikel/Luefterloses-Aldi-NAS-im-Kurztest-1757975.html

[[Kategorie:P89626| ]]
[[Kategorie:ARM-Boards]]

Diskussion:Elektronikversender

2012-12-16T19:30:26Z

Mthomas: /* PayPal */ Vorschlag übernommen, Hauptseite ergänzt

Warum wurde Shortec von Eurotronik gelöscht ?

Elektronikversender

2012-12-16T19:29:28Z

Mthomas: /* Pollin Electronic */

Die Vor- und Nachteile von verschiedenen Elektronik-Versand-Händlern werden relativ häufig im Forum diskutiert. Diese Diskussionen führen nicht selten zu weitestgehend gleichen Ergebnissen. In diesem Artikel sollen daher die Argumente, die für oder gegen einen bestimmten Elektronik-Versender sprechen, zusammengetragen werden. Sobald diese Liste einigermaßen vollständig ist, würde dies sicher einige Diskussions-Threads und/oder Flame-Wars überflüssig machen.

Diese Liste erhebt keinerlei Anspruch auf Vollständigkeit, d.h. wenn ihr einen Versender kennt, der hier noch nicht aufgeführt ist, dann nennt wenigstens die URL und den Namen. Den Rest können auch andere besorgen, die den Versender ebenfalls kennen!

Bitte ergänzt nur allgemeine Sachen (z. B. "liefert immer vollständig", "günstig" oder "große Auswahl"), aber nicht Sachen wie "mein ATMega 128 hatte verbogene Beine"! Bitte auch die alphabetische Sortierung beibehalten!

'''Diese Seite kann nur von angemeldeten Benutzern bearbeitet werden!'''

__TOC__

== Liste der Versender ==

=== AATiS ===
Homepage: http://www.aatis.de

* Arbeitskreis Amateurfunk und Technik in der Schule e.V.
* Bausätze speziell auch für Elektronik-Anfänger, Schüler
* Literatur, Seminare für Lehrer

=== Actron ===
Homepage: http://www.actron.de

* '''kein''' Online-Shop!
* alphanumerische LCDs und Graphikdisplays in großer Auswahl, auch mit Touchscreens
* für gewerbliche Kunden: etwas verhandeln schadet nie
* bei kleinen Stückzahlen nicht ganz billig
* liefern sehr schnell und stets zuverlässig



=== AK Modul Bus Computer GmbH ===
Homepage: http://www.ak-modul-bus.com/stat/produkte.html

* Interfaces, Messmodule, Funktionsmodelle, Experimentiersysteme
* Entwicklungssysteme, Baugruppen, Elektor, Zubehör, Bauelemente
* Software, Lernpakete, Bücher, Sonderposten

=== Allpax ===
Homepage: http://www.allpax.de

* Liefert auch an Privathaushalte
* Keine Elektronik an sich, aber ggf. nützliches Zubehör: Größeres, übersichtliches Sortiment an ESD-Beuteln und -Folien, offen und mit Zippverschluss, Pink Poly und Metallisiert (High Shield). Preislich über Farnell, dafür findet man sofort, was man sucht...
* außerdem Ultraschallreiniger, Waagen und Folienschweißgeräte, sowie viel Fachfremdes
* Versandkosten: 8,33€ nach Deutschland, diverse EU-Länder 17,85€, Schweiz 34,51€; Versandkostenfrei in D ab 178,50€
* Gewährt scheinbar auch Privatkunden die Zahlung per Rechnung; bei Bankeinzug 2% Rabatt, bei Vorkasse und Abholung 3%

=== AME-Engineering ===
Homepage: http://www.ame-engineering.de

* Hochfrequenz-Spezialitäten, Amateurfunk

=== Amidon ===
Homepage: http://www.amidon.de

* Sehr großes Sortiment, vorallem für seltene Bauteile, z. B. Dioden

=== Andy's Funkladen ===
Homepage: http://www.andyfunk.de

* Alles für Amateur- und CB-Funk
* Bauteile und Gehäuse

=== Anvilex ===
Homepage: http://shop.anvilex.com/index.html

* Liefert sehr günstige Break-Out Boards für diverse Packages
* Hat einige einfache und günstige Programmer auch für FPGAs etc

=== Atlantis Shop 24 ===
Homepage: http://www.atlantis-shop24.de

* Elektronik nur ein kleiner Teil des Angebotes. Ansonsten eher Drogerie bzw. Haushaltsbedarf

=== Atzert-Elektronik Versand ===
Homepage: http://www.atzert-elektronik.de

Früher ''EFB-Electronic Versand'', davor ''MEGAKICK Electronic Stores''.

* Mindestens schon der dritte Name und die dritte Webseite für den Endkunden-Versand von [[Elektronikversender#ETT|ETT]]. ETT liefert sonst nur an gewerbliche Kunden.
* Ladengeschäfte in Bielefeld, Braunschweig, Bremen, Hamburg und Berlin.
* Die Preise schwanken im Vergleich zu anderen Anbietern, welche ebenfalls ETT-importierte Produkte führen, mal nach oben, mal nach unten.

=== Bassenberg Elektronik ===
Homepage: http://www.bassenberg.de

* Ladengeschäfte in Braunschweig und Neumünster
* Beschafft auch nicht mehr gelistete und abgekündigte Bauteile
* Liefert auch an Privat

=== Batronix ===
Homepage: http://www.batronix.com
* Grosses Sortiment an Geräten
* Bausätze für Microcontroller-Applikationen
* Liefert auch an Privat

=== BAZ Spezialantennen ===
Homepage: http://www.spezialantennen.de

* Antennen für Amateurfunk, ISM, WLAN usw.

=== bed - elektronik ===
Homepage: http://www.bed-elektronik.de

* Restposten aktive und passive Bauelemente
* sehr günstige Preise
* alles ab Lager lieferbar
* Versand an Privat
* ab 60 EUR versandkostenfrei

=== Bfi-Optilas ===
Homepage: http://www.bfioptilas.de

* Kein Onlineshop
* spezialisierter Distributor für Hochfrequenzhalbleiter und Optik

=== BG-Electronics.de ===
Homepage: http://www.bg-electronics.de

* Online Shop für aktive und passive elektronische Bauelememte
* günstige Preise
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, CarHiFi und TV-Bereich



=== Box73 ===
Homepage: http://www.box73.de

Onlineshop des Funkamateur.

* Bauteile, Bausätze, Literatur aus dem Amateurfunkbereich
* Preise sind O.K.
* Bestellungen werden nur Di und Do bearbeitet
* Ab 50 EUR bei Bankeinzug portofrei.

=== Bürklin OHG ===
Homepage: http://www.buerklin.com

* große Auswahl, hohe Verfügbarkeit
* sehr schneller Versand
* Ladengeschäft in Oberhaching (südlicher Landkreis München)
* <s>nur an gewerbliche Abnehmer (lt. AGB), private Abnehmer können dennoch im Ladengeschäft einkaufen Angeblich versendet Bürklin seit November 2010 auch an Privatpersonen. Allerdings verlangt Bürklin weiterhin in Adressformularen die Eingabe eines Firmennamens Geben Sie einen Wert in das Feld "Firma" ein. Daher ist diese Information eher mit Vorsicht zu genießen.</s> Mittlerweile muss man auch keinen Firmennamen mehr eingeben. Die AGB wurde ebenfalls angepasst.

=== CBsoft, s.r.o. (ltd.) ===
*Homepage: http://www.jjtubes.eu/
* Firma in der Slowakei
* Verkauft Röhren der Firma JJ
* englischsprachig
* Zahlungsmöglichkeiten in € mit Paypal und Kreditkarte

=== chiptrade.com ===
siehe [[#SE Spezial-Electronic AG|SE Spezial-Electronic AG]]

=== ConeleK Electronic ===
Homepage: http://www.conelek.com

* Sehr kleines Bauteileangebot (Röhren, Röhrensockel)
* Elektronik-Laborbedarf, insbesondere Nachfüllpackungen mit Steckbrett-Drahtbrücken
* Werkzeug für Elektronik
* Stromversorgungen
* Versand an Privat
* Versandkosten bis 25kg, Vorkasse 5,90€ (Stand 04/2008)

=== Conrad ===
Homepage: http://www.conrad.de und http://www.business.conrad.de

* großes Angebot (für Bauteile den "Business"-Katalog beachten, der Hauptkatalog ist dahingehend etwas "dünn") (Anm.: Bauteile, die nur im Business-Katalog aufgeführt sind, sind in Ladengeschäften nur über Sonderbestellung zu bekommen, d.h. dort in aller Regel nicht vorrätig.)
* Positiv: Wirklich jedes Bauteil kann einzeln gekauft werden und wird nicht in dämlichen Verpackungseinheiten verkauft, so wie es bei den meisten anderen Elektronik-Lieferanten der Fall ist. Dies ist vor Allem für den Prototypenbau sehr hilfreich.
* relativ teuer jedoch bis zu 10% Rabatt für Schulen (bei genügend Umsatz)
* 21 Ladengeschäfte in Deutschland, fünf in Österreich
* positiv: Bei Business-Kunden wird der Rechnungsbetrag erst nach 14 Tagen abgebucht.
* haben einen (teuren) 24 Std. Lieferservice für Notfälle - Conrad garantiert aber nicht 100%ig für die Einhaltung der 24 Stunden. Bei Nichteinhaltung gibt es kein Geld zurück.
* Verfügbarkeit in Filialen kann Online überprüft werden.
* Verfügbarkeit in Filialen kann über zentale Rufnummer erfragt werden. Abholung bestellter Ware in Filialen möglich, aber trotzdem gleiche Versandkosten.


=== csd-electronics ===
Homepage: [http://www.csd-electronics.de csd-electronics.de]

* schnelle Lieferung, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung, '''teilweise sehr lange Lieferzeiten bei Ware die nicht ab Lager lieferbar ist'''. Bitte selbst abwägen ob dies für einen selbst akzeptabel ist. (Diskussion siehe hier [http://www.mikrocontroller.net/topic/273508] und hier [http://www.mikrocontroller.net/topic/249395].)
* ATMEL, ICs, Passive und Mechanische Bauteile, Platinen- und Lötzubehör, u.a.
* ca. 4000 Bauteile lagernd
* günstig
* Mengenrabatte für fast jedes Produkt
* Versand innerhalb Deutschlands:
* DPD: 3,75€ (ab 50 EUR versandkostenfrei)
* DHL: 4,50€ (ab 100 EUR versandkostenfrei)
* Versand EU-weit ab 5,95 EUR
* kein Mindestbestellwert
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage beschafft werden.
* Zahlung per Vorkasse (2% Skonto), PayPal, Nachnahme. 1 EUR Aufschlag bei PayPal-Zahlung
* Zahlung per Bankabbuchung, Kreditkarte oder Rechnung nur für Stammkunden (ab 4 bis 5 Bestellung), Für Institute/Firmen direkt auf Rechnung möglich

=== dad24 ===
Homepage, Shop: http://dad24.eu
E-Bay Shop: http://stores.ebay.de/Shop-dad24

* Unterschiedliche Preise in den beiden Shops
* Kleiner, nicht sonderlich schöner Onlineshop (dad24.eu)
* Kleines Angebot. Lupenleuchten, Lötstationen, Labornetzgeräte, Messgeräte, etc. aus dem unteren Preissegment
* Jede Woche eine neue "Kategorie der Woche" auf dad24.eu. Produkte aus der Kategorie werden erst im Warenkorb mit einem Rabatt angezeigt, der auch gewährt wird.

=== Darisus ===
Homepage: http://www.darisus.de

* kompetente Beratung
* liefert sehr zuverlässig, in Notfällen auch Express
* Versand innerhalb Deutschlands ab 4,50 EUR
* Hat auch eine gute Auswahl an CPLDs und einige FPGAs diverser Hersteller

=== Daschke LTD ===
PDF-Katalog (Achtung, grosse Datei): http://www.daschke-ltd.de/Catalog/

* Prompte Antwort und Hilfe via info ät obige adresse
* Bezahlung per Paypal und Rechnung möglich. Ist auch Ebay-Händler.
* sehr faire Preise für Bauteile und Versand
* Führt eine Vielzahl an unüblichen Steckern und Buchsen
* Nicht verfügbare Bauteile wurden proaktiv nachbestellt, trotz geringer Bestellmenge. Prima!

=== DES - Der Elektroniker-Shop ===
Homepage: http://www.DerElektronikerShop.de

* Bauteile
* Bauteilsätze der [http://www.DieElektronikerseite.de Elektronikerseite]
* Verkauf des BasicBeetle von [http://www.DieProjektseite.de der Projektseite]
* Ständig wachsendes Angebot
* Auch einige SMD-Bauteile verfügbar
* Kein Mindestbestellwert
* Versandkosten ab 3,50 EUR (Ab 1.1.13 3,70€) (Österreich/Europa ab 4,00 Eur)
* *** Versandkostenfrei an den Adventsonntagen bei einem Bestellwert ab 10,- € ***
* Versand auch nach Österreich (Europa auf Anfrage)
* Zahlung per Vorkasse
* Lieferzeit 1-3 Tage bei Verfügbarkeit
* PrePaid-Konto möglich
* Lieferungen auch an Privat

=== Digi-Key ===
(tlw.) deutsche Homepage: http://de.digikey.com

* optisch nicht besonders ansprechende, aber durchaus sehr funktionelle Website
* beheimatet in den USA, ein Logistikbüro gibt es in den Niederlanden
* kostenloser Versand ab 65€, darunter 18€ Versandkosten
* macht merkwürdige Plausibilitäts-Checks: wenn man privat über ihrem Dollar Limit (z.B. 400 Dollar bestellt) kommt sofort die Rückfrage nach Firmenname und Firmenadresse
* Rückfragen nach dem Verwendungszweck kommen ebenfalls schon bei der Bestellung bei bestimmten Bauteilen die der Exportkontrolle unterliegen
* Versand direkt aus den USA, dafür sehr flott mit UPS Express (in rund zwei bis drei Tagen da)
* riesiges Angebot, gewissermaßen ein Distributor der auch Kleinmengen an Privatpersonen liefert, entscheidend ist, dass der Hersteller des Produkts geführt wird
* kein anderer Anbieter, bietet so viele verschiedene passive Bauteile in kleinen Stückzahlen, z. B. SMD Widerstände in Bauform 01005 bis 2512 meist in verschiedenen Toleranzklassen und von verschiedenen Herstellern
* alle Bauteile mit Herstellerangabe, Digikey kauft ausschließlich direkt vom Hersteller
* Preise sind auf der deutschen Website in Euro inklusive etwaigem Zoll angegeben, allerdings ohne Mehrwertsteuer, die korrekt abgerechnet wird (d.h. man zahlt bei Versand nach Österreich 20% Mwst., nach Deutschland m.W.n. 19%)
* Meistens deutlich teurer als Reichelt, doch häufig die beste Anlaufstelle für Privatkunden wenn es um Spezialbauteile geht, und der Hersteller sich im Programm von Digikey befindet

* Zu beachten ist auch noch folgendes, um unliebsame zusatzkosten zu vermeiden: http://www.mikrocontroller.net/topic/90943#new. ''Anmerkung dazu: Digikey hat wohl zum 1.4.2011 den Versand umgestellt und importiert nun selbst. Zusatzkosten durch Verzollung sollten dann nicht mehr anfallen.''

=== Display Electronics ===

Homepage: http://www.distel.co.uk

* In England
* Webseite = Augenkrebs
* Online-Shop versteckt hinter dem Search-Button auf der Homepage
* Restposten aller Art
* Mindestbestellwert 10 GBP

=== eHaJo ===
Homepage: http://www.eHaJo.de

* Bausätze
* Lötübungen
* AVR-ISP-Stick

=== EIBTron.com ===
Homepage: http://www.eibtron.com

* Riesige Auswahl an Produkten (~300000)
* SMD-Bauteile bis 0402!
* auch spezielle Sachen wie Xilinx-Configuration PROMs, AD9740-DACs oder SMD-Quarze (z.B. Abracon ABM7) im Angebot
* Alternative zum HBE-Shop für Privatanwender!

=== Eisch-Kafka-Electronic ===
Homepage: http://www.eisch-electronic.de

* Hochfrequenz Bausätze und Bauteile für Amateurfunk

=== EleConT ===
Homepage: http://www.elecont.de/shop/

* Carrierboards für gebräuchliche AVR

=== Electropuces ===
Homepage: http://perso.wanadoo.fr/electropuces/

* Gebrauchte Messgeräte aus Nantes, Frankreich (teilweise engl. Menü)

=== Electronic Search ===

Homepage: http://www.electronic-search.de

* Keine Mindestbestellmenge
* Verkauf auch an Privat/Bastler
* Fast alle Preise im Online-Shop nur "auf Anfrage", und nicht im Shop angegeben.

=== electronicpool Rheinstetten ===
Homepage: http://www.electronicpool.de

* abgekündigte oder schwer beschaffbare elektronische Bauteile

=== Elektronikladen ===
Homepage: http://www.elektronikladen.de

* Spezialist für Mikrokontroller
* Entwicklungssysteme, keine Einzelbauteile
* entsprechende Literatur und Software
* "Kein Verkauf an Endverbraucher i.S.d. §13 BGB"

=== Elektronik-Kompendium ===
Homepage: http://www.elektronik-kompendium.de

* Bausätze diverser Schaltungen (mit Anleitung und Funktionsbeschreibung)
* erspart lästiges Suchen in anderen Shops
* kurze Lieferzeiten
* günstiger Versand

=== Elk Tronic ===
Homepage: http://www.elk-tronic.de

* kleines Lieferprogramm Adapterplatinen (SMD -> 2,54mm-Raster) und Programmieradapter
* günstige Preise und Versandspesen

=== Elko-Verkauf ===
Homepage: http://www.elko-verkauf.de

* Nur Low-ESR-Elkos
* Elko-Sets für ein Gerät

=== Ellmitron ===
Homepage: http://www.ellmitron.de/
Katalog: http://www.ellmitron.de/katalog.pdf

Lehrmittel, Kleinbausätze vor allem für Schüler, Experimentierkästen

=== Elpro Darmstadt ===
Homepage: http://www.elpro.org

* Kein Mindestbestellwert, aber hohe Versandkosten für kleine Bestellungen. Stand September 2008:
** Bis 15€: 9,95€ Versandkosten
** Von €15 bis €75: 5,95€ Versandkosten
** Von €75 bis €200: 4,49€ Versandkosten
** Ab €200: Versandkostenfrei
* Große Auswahl an Mikrocontrollern
* Sehr große Auswahl an Schaltnetzteilen von Meanwell (geschlossen, offen, auf PCB lötbar, DIN-Schiene)
* Merkwürdig zu bedienende Shopsoftware, ständig klappt was auf und zu und wird irgendwas nachgeladen. Braucht JavaScript
* Keine AGBs online. Da Preisangaben ohne MwSt. richtet sich das Angebot vermutlich nicht an Endverbraucher (werden aber beliefert)
* Bearbeitungszeit (bis Warenausgang) 2-3 Tage.
* Versand bisher mit DHL
* gute bis sehr gute Verpackung

=== Eltrix ===
Homepage: http://eltrix.de/Starteltrix.htm

* Verbrauchsmaterial, Tipps und Tricks fürs Leiterplattenherstellen und Löten

=== ELV ===
Homepage: http://www.elv.de

* nicht sehr große Auswahl an Einzelteilen
* riesiges Angebot an Zubehör für Hobbyisten
* viele z.T. pfiffige Eigenentwicklungen, Bausätze (auch zum Download auf der Website verfügbar)
* sonst Sortiment ähnlich Conrad, nicht billig
* im Allgemeinen nicht billig, merkwürdigerweise sind manche Artikel aber die günstigsten auf dem Markt
* mühsamer Onlinekatalog
* Immer mal wieder Fehllieferungen und Wartezeiten (zumindest in die Schweiz). Service erreichte in 3 Fällen nicht das inserierte Niveau.
* Versandkosten innerhalb Deutschland 4,5€, ab 150€ Bestellwert versandkostenfrei
* nicht abwählbare Versandversicherung, die 0,85% des Bestellwertes kostet



=== ETT - Electronic Toys Trading ===
Homepage: http://www.ett-online.de

* Großhandel nur für Gewerbekunden.
* Zweitshop [[Elektronikversender#Atzert-Elektronik_Versand|Atzert-Elektronik Versand]] (früher EFB-Electronic Versand, davor Megakick Electronic-Stores) für Endkunden.
* Ladengeschäft in Braunschweig für jedermann. Weitere Atzert Ladengeschäfte in Bielefeld, Bremen, Hamburg und Berlin.
* Eigentümer der Marken McCHECK®, McPower®, McVoice® und anderer, unter denen ETT importierte Messgeräte, Labornetzteile, usw. an Großkunden und Händler vertreibt. Diese sind unter oben genannten Marken dann in vielen Shops anderer Firmen für Endkunden zu finden, nicht nur bei Atzert. Preisvergleiche lohnen.

=== Ettinger GmbH ===
Homepage: http://www.ettinger.de

* Für gewerbliche Kunden
* Mechanische Komponenten (Gehäuse, Abstandshalter, Drehknöpfe, usw.)
* LEDs
* Gewöhnungsbedürftiger Online-Shop

=== Eurotronik GmbH ===
Homepage: http://www.eurotronik.com

* Für gewerbliche Kunden
* Mindestbestellwert 100.00 Euro
* Individuelle Suche für alle möglichen Bauelemente
* Abgekündigte und allokierte BE finden
* Besonders Stark mit Altera, Microchip, Texas Instruments

=== EVE ===
Homepage: http://www.eve.de

* Zitat aus den AGBs:
::''"Zu Bestellungen im Rahmen des Online-Handels sind nur durch uns autorisierte, d. h. zugelassene Käufer berechtigt. Wir gewähren nach erfolgreicher Zertifizierung – ohne hierzu verpflichtet zu sein – dem jeweiligen Käufer das nicht übertragbare, nicht exklusive Recht im Rahmen des Online-Handels Bestellungen uns gegenüber “auszubringen”."''

:Dies darf man wohl getrost als Hinweis ansehen, dass Endverbraucher als Kunden nicht gewünscht sind.
* Versandhaus für elektronische Artikel in Emsdetten
* machen auch Kabelkonfektion
* Pb-freie Artikel markiert

=== Farnell ===
Homepage: http://de.farnell.com

* liefert nur an gewerbliche Abnehmer, Ausnahme sind Studenten und HTL-Schüler (Österreich, Farnell.at). Nachweis wird verlangt (Gewerbeschein oder Immatrikulation).
* Lieferungen an Privat:
:* Schweiz: Farnell Schweiz beliefert auch Privatkunden.
:* Deutschland: Über den Reseller [[#HBE_-_Heinz_B.C3.BCchner_Elektronik.2C_Messtechnik.2C_med._Elektronik_e.K.|HBE]] kann man Produkte aus dem Farnell-Sortiment zu bestellen.
:* Österreich: [[#Technik-Welt / Industrieshop.at|Technik-Welt / Industrieshop.at]]
* große Auswahl
* 12% Rabatt für Studenten und Lehreinrichtungen
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (UPS), fehlende Positionen werden relativ rasch versandkostenfrei nachgeliefert
* Versandkosten: Bestellung bis 49,99€: 7,95€; 50,- bis 149,99€: 5,95€; ab EUR 150,- versandkostenfrei
* hat nach eigenen Aussagen umfangreichstes Sortiment an RoHS-konformen Bauteilen mit Suchfunktion im WWW
* leistungsfähige parametrische Suchfunktion / teils aber völlig nutzlos, da den Artikeln massenweise Tags fehlen, weswegen die Suchergebnisse unnötig eingeschränkt werden
* Datenblätter für die meisten Bauteile online
* Internetpräsenz fällt nachts oft aus (Hinweis auf angebliche geplante Wartungsarbeiten)
* Sortierfunktion wird bei der Suche ständig zurückgesetzt, im Warenkorb ist überhaupt keine sinnvolle Sortierung möglich
* Eigenwillige Preispolitik: Einiges sehr günstig, Anderes total überteuert

=== Fibra-Brandt Zweibrücken ===
Homepage: http://www.fibra-brandt.com

* lagert tausende veraltete und schwer zu findende elektronische Bauteile
* Halbleiter, IC's, Transistoren, Spulen und Kondensatoren.
* Sonderbeschaffung von abgekündigten Halbleitern.

=== Fischer DK2FD ===
Homepage: http://www.dfe-online.de für das Ingenieurbüro,
Homepage: http://www.dk2fd.de für Amateurfunkprodukte

* Baugruppen für Hochfrequenzmesstechnik und Amateurfunk

=== Funkamateur Online-Shop ===

Siehe [[Elektronikversender#Box73]]

=== Futurelec ===
Homepage: http://www.futurlec.com

* günstiger Versender aus Übersee
* viele Stamp-Boards
* LED Matrix-Module

=== Future Electronics ===
Homepage: http://de.futureelectronics.com

* große Auswahl an Teilen
* Versand auch an Privatpersonen
* Preisangaben ohne MwSt.
* Zahlung nur mit Kreditkarte
* Versandkosten 7,14€ (Brutto)
* Versand aus den USA mit FedEx, Lieferzeit meist unter 5AT
* Verzollung usw. wird von FutureElectronics gemacht, keine Nachzahlungen etc.

=== Geist Electronic-Versand GmbH ===
Homepage: http://www.geist-electronic.de

* Liefern Bauteile für Elektor-Projekte
* D-78054 Villingen-Schwenningen
* Versandkosten: 5.40€

=== Giga-Tech ===
Homepage: http://www.giga-tech.de

* Spezialitäten für Hochfrequenz / Amateurfunk
* Scheinbar nur noch Abverkauf, da viele Artikel nicht mehr lieferbar
* Antworten auf Anfragen und Lieferungen dauern sehr lange
* 68542 Heddesheim

=== Grummes Elektronik ===
Homepage: http://www.grummes.de

* Elektronikversender /CNC-Fräsmaschinen / Schrittmotorsteuerungen / Bauteile
* Homepage nicht aufrufbar (10.12.2011)

=== Glyn (GLYNshop) ===
Homepage: https://www.glynshop.com/erp/welcome.do

* "B2B Shop" = nicht für Privatkunden
* Microcontroller, Evaluation Boards, TFT-Displays, LC-Displays, Memory Cards u.a.

=== guloshop.de ===
Homepage: http://guloshop.de

* kleiner Shop, konzentriert sich auf Standard-AVRs im DIP-Gehäuse, ist dabei aber meist der billigste Versender in Deutschland
* ATtiny, ATmega, Breakout-Boards, Programmer, Adapterkabel, IC-Fassungen
* AVR mit geflashtem Arduino-Bootloader
* äußerst niedrige Preise
* liefert schnell und zuverlässig, jedoch nur gegen Vorkasse
* kein Mindestbestellwert, Versandkosten für kleine Bestellungen: 2,40 EUR, darüber 4,40 EUR
* ansässig in 90489 Nürnberg

=== H-Tronic ===
Homepage: http://www.h-tronic.eu/index.php

* Online-Shop einer Entwicklungsfirma, in dem neben Baugruppen und Geräten auch einige Bauelemente und Elektronikzubehör angeboten werden
* kleines Angebot

=== Hallmanns Elektronik ===
Homepage: http://www.hallmanns.com 
Adresse: Bruno Hallmanns, Weierstraße 41, 52349 Düren

* Elektronikhändler mit Ladenlokal und Versand
* Ladentypisches Sortiment (Bauteile, Geräte, PC, Funk, Hifi...)

=== Hari Seligenstadt ===
Homepage: http://www.hari-ham.com

* Bausätze, Ringkerne, Geräte für Amateurfunk

=== HBE - Heinz Büchner Elektronik, Messtechnik, med. Elektronik e.K. ===
Homepage: http://www.hbe-shop.de/katalog/

* Bezeichnet sich als ''[[#Farnell|Farnell]] Fachhändler'', bei dem nichtgewerbliche Kunden aus dem Farnell-Sortiment bestellen können.
* Preise für Farnell-Produkte normalerweise Farnell Netto-Preis + MwSt.
* Mindestbestellwert 25,- € (netto), Mindermengenzuschlag 5,- € (Stand 06/2010)
* Versandkosten 4,75 € (netto), ab 75,- € (netto) versandkostenfrei (Stand 06/2010)

=== Heho-Elektronik ===
Homepage: http://www.heho-elektronik.de
* Halbleiter / Bauteile, Sortimente, Handy - Akkus, VELLEMAN - Bausätze
* Aktuelles Angebot, Ladegeräte / Akkuladegeräte, Blei - Akkus
* Spannungswandler, Audio / Video / USB - Kabel, Netzwerk - Kabel
* 1-2 Arbeitstage für Waren ab Lager
* Porto + Verpackung pauschal Euro 4,50
* Mindestbestellwert von € 10,00

=== Hinkel ===
Homepage: http://www.hinkel-elektronik.de

* Von der Webseite "Unser Angebot richtet sich an Schulen, Behörden, Handel, Handwerk und Industrie."
* Batterien
* Knopfzellen, spezielle KZH, die man sonst lang sucht, findet man hier
* Mindestbestellwert von 20€
* Standardversand innerhalb Deutschlands 5,80€

=== HN Electronic Components GmbH & Co. KG / Netzteilshop ===
Homepage gewerbliche Kunden: http://www.hn-electronic.de/
* Netzteile aller Art
* Es gibt keinen Onlineshop mehr, wahrscheinlich werden Endkunden nicht beliefert
** Homepage Endkunden: http://www.netzteilshop.com/hnshop.html
** Lieferung an Endkunden nur per UPS Nachnahme.
** Mindestbestellmenge für Endkunden 25 €

=== Home-Electronic24 ===
Homepage: http://www.home-electronic24.de/

=== HW-Electronics ===
Homepage: http://www.hw-electronics.de 
Homepage EU: http://hw-electronics.eu/

* Tauch- und Sprühätzanlagen
* Entwicklungsgeräte
* Belichtungsgeräte, Materialsätze zum Selbstbau von Belichtungsgeräten

=== ID-Elektronik ===
Homepage: http://www.id-elektronik.de

* Amateurfunk-Baugruppen

=== IT-WNS ===
Homepage: http://www.it-wns.de

* "Bauteile, Platinen, Bausätze" insbesondere mit ATMEGA und ENC28J60
* Bausätze zu Projekten aus dem Forum, z. B. USBprog, ChipBasic, Mikro-Webserver, Transistortester u.v.a.m.
* Atmega32/644 Experimentiersystem als Bausatz mit vielen Zusatzmodul-Bausätzen
* SD-Slots, RFID, Bluetooth-Module, AVR Mikrocontroller uvam.
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage (Kontaktformular) beschafft werden
* günstige Preise und Versandkosten ab 1,90EUR, kein Mindestbestellwert
* schneller Versand, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung

=== Kabelscheune ===
Homepage: http://www.kabelscheune.de

* "Direktversand von Elektromaterial und Multimediaprodukten"

=== Kelemen ===
Homepage: http://www.kelemenantennen.de/Kelemen-Shop/

* Messgeräte, Antennen und Zubehör für den Amateurfunk

=== Kessler ===
Homepage: http://www.kessler-electronic.de

* im Preis-Leistungsverhältnis mit Reichelt zu vergleichen (sprich: günstig)
* Sortiment kleiner als Reichelt und mit gewissen Abweichungen (z. B. andere FPGA und RAMs)
* oft lange Lieferzeiten
* Versandkosten innerhalb Deutschlands 4€ (Brief), 5€ (DHL-Paket), 10€ (DHL-Express-Paket)

=== Klein-Electronic ===
Homepage: http://www.klein-electronic.de

* Baugruppen zur Video- und 2,4GHz-Sendetechnik

=== Konni-Antennen ===
Homepage: http://www.konni-antennen.de

* Antennen für TV, Amateurfunk
* Zubehör, Einzelteile
* sehr netter kompetenter Service

=== Köditz Nachrichtentechnik ===
Homepage: http://www.koeditz-nachrichtentechnik.de

* Baugruppen und Bauteile für Amateurfunk und TV-Satellitenempfang

=== Kuhne DB6NT ===
Homepage: http://www.kuhne-electronic.de

* Baugruppen und Bausätze für Mikrowellenamateure

=== LEDSEE Electronics ===
Homepage: http://www.ledsee.com

* LEDs, LCDs, diverses
* Lieferung direkt aus China, daher sehr günstig und lange Lieferzeiten

=== LED Microtechnics LTD ===
Homepage: http://www.ledmeile.de

* "LED Shop und Lampentechnik"

=== LED-Tech LED-Shop ===
Homepage: http://www.led-tech.de

* viele verschiedene LEDs zu sehr guten (meist den günstigsten) Preisen
* vor allem auf High-Power-LEDs spezialisiert
* viele verschiedene Treiber für High-Power-LEDs
* kostenloser Versand
* haben ein eigenes, sehr umfangreiches Forum

=== Lieske Elektronik ===
Homepage: http://www.lieske-elektronik.de

* liefert nur an Geschäftskunden

=== Lüdeke Elektronic ===
Homepage: http://www.luedeke-elektronic.de/

* großes Sortiment, bietet unter anderem auch viele selbst entwickelte Bausätze an

=== LUMITRONIX LEDs-Shop ===
Homepage: http://www.leds.de

* alles rund um LEDs (auch Zubehör und Lektüre)
* neben Standard-LEDs auch SMD- und SuperFlux-LEDs

=== Marsch Elektronik, M. Schlimper ===
Homepage: http://www.marsch-elektronik.de

* Online Shop für aktive und passive Bauelemente
* Versandkosten ab Euro 1,60
* kein Mindestbestellwert
* bietet auch Einsteigersortimente und Widerstandsortimente (auch SMD)
* liefert nur innerhalb Deutschlands
* nicht gelistete Artikel können angefragt werden und werden meist auch beschafft

=== Mauritz Communication & Electronics ===
Homepage: http://www.mauritz-shop.eu

* Online Shop für HF-Stecker und Kabel
* bietet HF-Stecker/Buchsen und Koaxkabel an
* große Auswahl, auch exotische Teile
* Kabelkonfektionierung nach Wunsch
* vernünftige Preise
* liefert nach Rücksprache auch weltweit
* Keine Mindestbestellwert, aber 5 € Aufschlag unter 15 €
* Versand bis 40 kg pauschal 5,95 € per GLS innerhalb DE
* schneller Versand
* Paypal oder Vorkasse

=== Mein-Daarle ===
Homepage: http://www.mein-st-arnual.de/shop/saarbruecken/artikellisteL.html

* Teileliste eines "Händlers aus Saarbrücken" (wahrscheinl.: Frank Skowronek ESS Elektronik Service), "bis sein Onlineshop ans Netz gehen kann"
* derzeit (4/2011) kein Onlineshop, Kontakt über Formular

=== Micromaus ===
Homepage: http://www.micromaus.de

* Sensoren
* Mikrokontroller
* kein Mindestbestellwert
* 22.7.2012: Totalausverkauf wegen Geschäftsaufgabe, 10% auf alle Artikel

=== Microcontroller-Starterkits ===
Homepage: http://www.microcontroller-starterkits.de

* 22.7.2012: Seite nicht erreichbar
* Bauteile: CAN, Ethernet, Mikrokontroller AVR und ARM, Linearregler 1,8V 3,3V 5V in SOT223
* Leerplatinen, Bausätze
* günstig
* Abholung in Hattingen möglich
* Versandkosten innerhalb Deutschlands ab 2,50€
* keine Kreditkartenzahlung möglich

=== Mikrocontroller.net ===
Homepage: http://shop.mikrocontroller.net

* Starterkits, Development Boards und Zubehör für AVR, AVR32, ARM und MSP430

=== Mira Nürnberg ===
Homepage: http://www.mira-electronic.de

* SMD-Bauteile, SMD-Sortimentboxen
* Verkauf und Preisangaben nur für Gewerbetreibende



=== Mouser ===
Homepage: http://de.mouser.com

* Liefert an Privat
* Zügige Lieferung mit FedEx aus den USA
* Keine Halbleiter von Linear, National und Analog

=== MS-Elektronik ===
Homepage: http://www.ms-elektronik.info

* Liefert an Privat
* Zügige Lieferung
* Gute Qualität
* Viel in Richtung Audio
* Große Auswahl an Elkos -> kleine Preise
* kein allzu großes Sortiment

=== Mütron ===
Homepage: http://www.muetronshop.de

* Keine Privatkunden

=== myAVR Shop ===
Hompage http://shop.myavr.de

* Kleine Auswahl, aber die angebotene Ware ist sehr preiswert (meist preiswerter als bei Reichelt)
* Zügige Lieferung (1-2 Werktage)
* Diverse Zahlungsmöglichkeiten: Rechnung, Vorkasse, Lastschrift, Kreditkarte, PayPal
* Kein Mindestbestellwert
* Sehr günstige Versandkosten ab 1,95 Eur
* Mengenrabatt ab 10 gleichen Artikeln

=== Neuhold-Elektronik ===
Homepage: http://www.neuhold-elektronik.at 
Shop: http://www.neuhold-elektronik.at/catshop/default.php?language=de

* preiswerte Schnäppchen
* regelmäßig aktualisierte Angebotsliste herunterladbar
* Ab 60,- EUR versandkostenfrei in Österreich

=== Octamex ===
Homepage: http://www.octamex.de

* Leiterplattenchemie (Entwickler, Ätzmittel, CRC-Sprays)
* Chemisch Zinn
* Lötstopp-Laminat, Tentingresist, Bestückungsdruck
* Bungard Basismaterial in 0,5mm 1,0mm 1,5mm Dicke und 18µm, 35µm, 70µm Kupfer
* Bungard Alucorex für 19" Frontplatten
* Bungard Cotherm, Alukernbasismaterial
* Funkmodule 434MHz, 868MHz, 2.4GHz
* Löttechnik und Zubehör
* Gehäuse aller Art
* Messgeräte und Labornetzteile
* aktive, passive u. mechanische Bauelemente (Widerstände, Kondensatoren, Transistoren, Logik-ICs etc.)
* kein Mindestbestellwert
* Lieferung auch ins Ausland
* Versandkosten ab 4,50EUR
* Liefert nur gegen Vorkasse, ausser für Bestandskunden, die schon häufig bestellt haben
* Zahlung mit EC-Pay oder Kreditkarte nur gegen Aufschlag (bis zu 5%)

=== Online Batterien ===
Homepage: http://www.online-batterien.de

* Allerlei günstige Batterien & Akkus vieler Marken
* z. B. '''40 Stk.''' DURACELL PLUS LR6 AA 11,59€ (Jan 2010)
* Beleuchtungsartikel
* USV
* Versand ab 3,90€

=== Oppermann ===
Homepage: http://www.oppermann-electronic.de

* Restposten, auch HF Bauteile
* auch Privatkunden
* Lieferung nach üblicher Zeit

=== PCB-Soldering ===

Homepage, Online-Shop: http://www.pcb-soldering.co.uk
eBay: http://www.allendale-stores.co.uk
Firmen-Homepage: http://www.allendale-elec.co.uk

* [http://www.aoyue.com/en/products.asp Aoyue] Lötstationen und preiswertes Zubehör (Lötspitzen) für diese. Bei Aoyue-Zubehör bessere Preise (Stand 10/2008) als [[#WilTec_Wildanger_Technik_GmbH|WilTec]]
* Schnelle Lieferung
* Dank [http://www.zoll.de/b0_zoll_und_steuern/a0_zoelle/a1_grundlage_zollrecht/b0_zollgebiet/index.html EU Binnenmarkt] nur britische Mehrwertsteuer (VAT), kein Zoll, keine [http://www.zoll.de/b0_zoll_und_steuern/a3_einfuhrumsatzsteuer/index.html Einfuhrumsatzsteuer] fällig.
* Zwei von drei E-Mails wurden nicht beantwortet
* Versandart wurde eigenmächtig von "Standard" auf teureres "Signed for" (Einschreiben) geändert

=== Pollin Electronic ===
Homepage: http://www.pollin.de

* Günstige Restposten aller Art (z. B. "250 g verschiedene ICs" u.dgl.)
* Produktkategorien:
** Computer und Zubehör
** Telefone und Zubehör
** Antennentechnik
** HiFi/Car-HiFi/Video/TV
** Stromversorgung
** Lichttechnik
** Messtechnik / Uhren
** Haustechnik
** Werkstatt
** Bauelemente
** KFZ- und Zweirad
** Motoren
** Bausätze
** Fundgrube
* Produkte teils schnell ausverkauft
* Qualität schwankend. Man kann gute Schnäppchen machen aber auch reinfallen. Umtausch ist dann aber problemlos.
* Es wird öfters von sorgloser Verpackung berichtet, trotz Verpackungspauschale von 0,85 % des Warenwerts (empfindliche und schwere Produkte besser nicht zusammen bestellen). Reklamationen bei Beschädigungen werden freundlich behandelt.
* Lieferzeit i.d.r. 2-3 Werktage / knappe Woche bei neuer Sonderliste
* Ladengeschäft in 85104 Pförring
* Versandkosten innerhalb Deutschlands 4,50 € (ab 150€ versandkostenfrei); dazu 0,85 % Verpackungspauschale
* Zahlung per Nachnahme (+2,50 €), Bankeinzug, ''SOFORT''-Überweisung oder PayPal

=== proma / Isel ===
Homepage: http://www.isel.com/en/proma_systro.php

The proMa systro GmbH has completed its business transactions since the 20th February 2009.
Nachfolger: http://idimod.iselshop.de/
<s>
* fotobeschichtete Leiterplatten Platinenfrästechnik
* Chemikalien für die Platinenherstellung: Ätzmittel, Flussmittel für Lötanlagen, etc.
* Profilgehäuse, u.a. von Conrad und Reichelt vertrieben
</s>

=== QRP-project ===
Homepage: http://www.qrpshop.de/

* Bausätze vor allem einfache Kurzwellen-Funkgeräte

=== Reichelt ===
Homepage: http://www.reichelt.de

* relativ große Auswahl, aber nicht viele "brandaktuelle" Bauteile
* wenn man höflich fragt, liefern sie ganz selten auch Bauteile, die nicht im Katalog stehen zu "normalen" Preisen (vorausgesetzt der Hersteller ist im Sortiment), z. B. Xilinx XC2S50, aber meist erhält man die Antwort, dass der Artikel nicht im Sortiment ist, obwohl auf der Homepage unter Service extra ein Punkt angeführt ist: "Ich benötige einen Artikel, der nicht im Programm ist"
* reagiert aber teilweise auch auf Anregungen, neue Produkte in das Angebot aufzunehmen; siehe dazu auch den Artikel [[Reichelt-Wishlist]]
* liefert schnell und vollständig; wenn etwas ausnahmsweise nicht verfügbar ist, dann liefern sie es auf eigene Kosten nach, wenn der Artikel in absehbarer Zeit wieder vorrätig ist (selbst wenn er nur 0,20€ wert ist).
* lässt einen dennoch manchmal warten, wenn ein Artikel nicht lieferbar ist! Daher bei der Bestellung immer darauf hinweisen, dass man auch eine Teillieferung akzeptiert. (Laut Auskunft dauert das länger, besser nach der Inet-Bestellung anrufen und nicht lieferbare Teile aus der Bestellung streichen lassen)
* Lieferzeiten normalerweise 2 - 4 Arbeitstage
* niedrige Preise (aber unbedingt Qualität des Artikel checken)
* Versandkosten 5,60€ (Deutschland); 10€ Österreich; Schweiz 16€; EU 15 - 19€;
* 10€ Mindestbestellwert für alle Länder
* auch in die Schweiz sehr guter Service
* holt sich auch ohne Erlaubnis Bankauskünfte bei großen Bestellungen ein

=== RF Microwave ===
Homepage: http://http://www.rfmicrowave.it/

* Ausschliesslich HF Bauelemente
* riesige Auswahl an Bauteilen für den Mikrowellenbereich
* Bestellung nur nach Registrierung im Shop
* Schnelle Lieferung
* Firmensitz in Italien
* Teilweise englischer Shop

=== RFW Elektronik ===
Homepage: http://www.rfw-elektronik.de

* HF Bauelemente

=== Ribu ===
Homepage: http://www.ribu.at

* Sehr guter Elektronikversand in Österreich mit zahlreichen Entwicklungsboards und zahlreichen Elektroniklösungen.
* Liefert sehr schnell und hat eine ausgezeichnete Beratung.
* Online-Shop ist sehr übersichtlich und einfach zu bedienen.
* Lieferstatusanzeige für alle Artikel. Bei Auslaufartikeln ist sogar die noch verfügbare Stückzahl sichbar.
* Günstige Sonderangebote
* innerhalb Österreichs 4,90€ Versandkosten, ab 80,- keine Versandkosten
* ausserhalb Österreichs 13€ Versandkosten, ab 225€ versandkostenfrei
* liefert auch an Privatkunden
* Mindestbestellwert innerhalb Österreichs 10€, ausserhalb 30€

=== Richardson Electronic ===
Homepage: http://www.richardsonrfpd.com/

* Hochfrequenz-Halbleiter, HF-Röhren,

=== Riedl Elektronik ===
Homepage: http://www.riedl-electronic.at

* großes Angebot v.a. ICs und Trafos
* recht günstig
* Rabatt für Schüler/Student
* Versand nach AT: 3,95€ bis 1kg, ab 100€ frei Haus
* Versand AT über 1kg sowie Ausland: Nach Aufwand (wird nicht direkt angezeigt)

=== RLX COMPONENTS s.r.o. ===
Homepage: http://www.rlx.sk

* Man spricht Deutsch
* Messgeräte, Mikrocontroller-Boards, Bauelemente

=== RM Computertechnik GmbH ===
Homepage: http://www.rm-computertechnik.de

* Kerngeschäft ist PC-Technik, aber auch großes Sortiment an Kabeln, Litzen und Steckverbindern
* handelt auch mit einigen Bauelementen, wie LED's

=== Robotikhardware===
Homepage: http://www.robotikhardware.de

* Microcontroller
* Entwicklungsboards
* Sensoren
* Robotik-Zubehör
* günstige Angebote für Hobbyelektroniker
* auch einzelne Platinen

=== Robotik-Teile.de===
Homepage: http://www.robotik-teile.de

* Große Auswahl an Elektronik Produkten
* Microcontroller, Sensoren, Zubehör, u.v.m.
* Versandkosten betragen immer 4,90 €
* Zahlbar ber PayPal, Sofortüberweisung, Vorkasse und Nachnahme

=== Benno Rößle Elektronik ===
Homepage: http://www.roessle-elektronik.de

* Masten, Antennen, Befestigungsmat.,Zubehör, Geräte, Anpassteile, HF-Stecker

=== RS Components ===
Homepage: http://de.rs-online.com

* lt. AGB nur an gewerbliche Abnehmer und an Studenten. Bei Internetbestellungen wird per Mail nach Belegen gefragt.
* gute Auswahl insbesondere an "mechanischen Bauteilen"
* gute Verfügbarkeit
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (GP)
* Preise wurden angepasst, gute Preis/Leistung
* Preis im Onlineshop sind ohne MwSt angegeben
* Bei Onlinekauf ab 50 Euro ist der Versand kostenfrei, ohne Mindesbestellwert.
* Notify-Me Service für Produktabkündigung
* Auch größere Stückzahlen über Allied möglich
* Relativ große Auswahl an Sortimenten (Widerstände, Kondensatoren), Einzelteile können teilweise nachgekauft werden
* Verfügbarkeitsanzeige im Internet ist ziemlich hilfreich
* Nützliche Tipps zum Thema RoHS
* Macht anscheinend Abfragen bei SCHUFA & Co. ohne Einverständnis oder Hinweis in den AGB.

=== Sander Elektronik ===
Homepage: http://www.sander-electronic.de

* beliefert auch Privatkunden, Bankeinzug möglich
* ähnlich Segor ein Berliner Versender
* Hier findet man manche [[MSP430]], die es sonst nicht in kleinen Stückzahlen gibt
* Herr Sander ist sehr kompetent und selbst Autor von Fachartikeln
* selbst abgekündigte Halbleiter können noch beschafft werden
* Bezahlung auch mit Kreditkarte möglich
* Versandkosten innerhalb Deutschlands ab 3,35€, innerhalb Europas ab 6€

=== Sasco Holz ===
Homepage: http://www.sasco.de

* Wie Spoerle eine Tochter von Arrow.
* Distributor für Analog Devices...
* Liefert wie Spoerle und Arrow in Deutschland nicht an Privatkunden.

=== Sat-Schneider ===
Homepage: http://www.sat-schneider.de
* Bauteile, Ersatzteile Online-Shop
* Baugruppen zum Empfang des Digitalen Kurzwellenrundfunks DRM

=== Satistronics ===
Homepage: http://www.satistronics.com

* typischer "China-Versender", mit allen Vor- und Nachteilen
* Lieferzeit bei Standardversand sehr lange (etwa 1 Monat nach D), aber schnellere Lieferung gegen Aufpreis möglich
* tritt auch bei eBay in Erscheinung ([http://stores.ebay.de/satistronicsstore eBay-Shop]), die Preise dort sind in der Regel aber etwas höher als im Online-Shop

=== Otto Schubert GmbH ===
Homepage: http://www.schubert-gehaeuse.de

* Kein Online-Shop. Bestellungen nur per Telefon, Fax oder E-Mail
* Weissblechgehäuse, Gerätegehäuse, wetterfeste Gehäuse
* Drehkondensatoren
* Sonderanfertigungen
* ansässig in 90574 Roßtal

=== Schramm-Software ===
Homepage: http://www.schramm-software.de/bausatz/
* Online-Shop, bietet Elektronik-Bausätze mit Mikrocontrollern
* Bausätze als Lehrmaterial geeignet, da ausführliches Begleitheft mitgeliefert wird (Aufbauanleitung, Schaltung, Controllerprogramm, Experimente...)
* bisher nur ein relativ kleines Sortiment, soll ergänzt werden
* Versandkosten innerhalb Deutschlands 2,50 €, innerhalb der EU 3,50 €

=== Schukat elektronic ===
Homepage: http://www.schukat.de

* liefert nicht an privaten Endverbraucher
* einfache und passiver Bauteile oft nur in großen Mindeststückzahlen
* ICs teilweise recht preiswert (vor allem bei mehr als 1 Stück, z. B. auch AVR)
* LCDs sehr preiswert und auch als Einzelstücke
* aktuelle Preise und Verfügbarkeit im Internet (aber nur nach Anmeldung -jetzt nicht mehr bei kleinen Stückzahlen), ebenso Bilder von Gehäusefootprints u.dgl.
* Abholung in Monheim am Rhein nach Vereinbarung möglich
* Versandkosten innerhalb Deutschlands ab 5€ (bis 10kg!)

=== Schuricht ===
Homepage: http://www.schuricht.de

* deutscher Ableger der Distrelec- (Elektronik) und Disdata-Gruppe (Computertechnik)
* Liefert auch an Privatkunden (getrennte AGBs für gewerbliche und Privatkunden, Lieferung an Privat per Nachnahme: Versandkosten ab 6,54€ plus 4,76€ Nachnahmegebühr).
** Online-Bestellung von Privatkunde scheiterte daran, dass die Onlineshop-Bestellformulare nur für gewerbliche Kunden ausgelegt sind und der Onlineshop Bestellungen ohne Firmenangaben nicht annimmt oder gar mit einer internen Fehlermeldung quittierte.
**Online Bestellung mit "Privat" als Firmenangabe funktionierte einwandfrei.
**Telefonische Bestellung von Privat funktioniert. Nette, freundliche Behandlung am Telefon, kein Callcenter. Versprochener Rückruf erfolgte mit gewünschten Informationen. Neben Nachnahme wurde für einen relativ teuren Artikel persönliche Abholung angeboten. Angegebene Lieferfrist wurde leicht unterschritten.
* Papierkatalog über 2000 Seiten, durchgehend farbig, nur für Geschäftskunden erhältlich.
* Ziemlich teuer

=== Schuro Elektronik GmbH ===
Homepage: http://www.schuro.de

* Elektronische Bauelemente und Bauteile für den Audio- und Lautsprecherbau (Kondensatoren, Spulen u.dgl.)
* kein Mindestbestellwert
* Versandkosten innerhalb Deutschlands gewichtsabhängig ab 5,75€

=== Segor-electronics ===
Homepage: http://www.segor.de

* Spezialist für Halbleiter, die ansonsten für nicht-gewerbliche Abnehmer nur schwer erhältlich sind (Preise dahingehend "angemessen")
* auch Privatkunden gerne gesehen
* Ladengeschäft in Berlin
* kein Mindestbestellwert bei Versand innerhalb der EU

=== SE Spezial-Electronic AG ===
Homepage: http://www.spezial.de

* Distributor
* Laut AGB auch Verkauf an Privat.
* Große Verpackungseinheiten/Mindestbestellmengen pro Bauteil
* Versandkosten pauschal 9,- € (Deutschland) (Stand 08/2008)

=== Small Control Shop ===
Homepage: http://www.small-control.de

* "Bernd Walter Computer Technology"
* kleines Lieferprogramm aber ein paar interessante Produkte

=== SMG Diffusion - F1GE ===
Homepage: http://www.smgdiffusion.com
( Seite nur französisch )

* Videotechnik,
* 1,2 GHz / 2,4GHz Module
* Gebraucht-Messgeräte HP, Tek, Philips u.a.
* GHz-Halbleiter
* Koax-Adapter
* Antennen

=== Spoerle ===
Homepage: http://www.spoerle.de

* Früher eine Tochterfirma von Arror. Mittlerweile komplett in Arrow aufgegangen, Webseite leitet auf Arrow um.
* Aus dem Webshop: "Unser Angebot richtet sich nur an Kaufleute und nicht an Verbraucher."
* Wenn es wirklich über Arrow sein muss, dann kann man es als Privatperson bei Arrow Electronics North American Components http://www.arrownac.com/ versuchen, die sich normalerweise nicht weigern ihre Produkte zu verkaufen. Allerdings muss man mit großen Mindestmengen (z. B. BC547 in Schritten von 2000 Stück) und hohen Kosten rechnen.
:Zu den Kosten gehören zum Beispiel ein mehrfacher Mindermengenzuschlag (''$10 handling charge will be added to each line item less than $30''), eine satte ''handling and energy fee of $10.22'' (mehr als 10x zu hoch wie die vergleichbare Gebühr für amerikanische Besteller), hohe Versandkosten (ab $20 nach Deutschland). Dazu kommen die üblichen Kosten für den Import aus dem Ausland (Einfuhrumsatzsteuer, Kreditkartengebühr, ...)

=== SR-Systems ===
Homepage: http://www.sr-systems.de

* Baugruppen für Digital-TV, Sende- und Empfangstechnik
* DVB-S, DVB-T

=== Strixner&Holzinger ===
Homepage: http://www.sh-halbleiter.de

* Ladengeschäft in München
* Versand
* riesiges Angebot an Halbleiter, auch schwer beschaffbare
* Online-Shop

=== TAUTEC-ELECTRONICS ===
Homepage: http://www.tautec-electronics.de

* Online Shop für aktive elektronische Bauelemente
* günstige Preise (Vorsicht, Preisangaben enthalten keine Mehrwertsteuer) aber Mindestbestellwert 100 Euro
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, Car-HiFi und TV-Bereich

=== TCB-Versand ===
Homepage: http://www.tcb-versand.de

* insbesondere für Modellbauer ein sehr interresantes Sortiment
* Stecker,Kabel etc. recht günstig und kleine Mengen abnehmbar
* Lieferung normal zwischen 1 und 3 Tage
* leider nur Online-Shop

=== TecHome.de Online-Shop ===
Hompage: http://www.techome.de/index.html

=== Tec-Shop (Wolfgang Rompel Elektronik) ===
Homepage: http://www.tec-shop.de

* Kleines, aber ausgesuchtes Sortiment
* Interessantes Angebot an Sensoren

=== Technik-Welt / Industrieshop.at ===
Homepage: http://www.industrieshop.at

* Laut Homepage richtet man sich "an den industriellen Kunden". Laut AGB sieht man das jedoch nicht so eng, Zitat:
:: ''TW schließt online Verträge nur mit Kunden ab, die natürliche oder juristischen Personen sind, die ihren Wohnsitz oder Sitz in Österreich, einem Mitgliedsstaat der Europäischen Union (EU25) oder der Schweiz haben.''
* [[#Farnell|Farnell]] Teile
* In Österreich
* Schnelle Lieferung (2 Tage)

=== Teske electronics ===
Homepage: http://www.teske-electronics.de

* Noch relativ übersichtliches Produktsortiment (Dez. 2012) aber schon einige interessante Teile
* Bisher überwiegend SMD Bauteile
* Kein Mindestbestellwert
* Versandkosten ab 2,85€
* Lieferung nur innerhalb Deutschlands
* Wunschliste für neue Produkte
* Beschaffung von Bauteilen möglich, die nicht im Shop angeboten werden
* Zahlung per Vorkasse, PayPal, Nachnahme oder Rechnung (für Stammkunden) möglich.

=== Thinkembedded.ch ===
Homepage: http://www.thinkembedded.ch

* in der Schweiz (auch Abholung möglich), Versand CH ab SFr 12.- (bis 5kg)
* keine Mindestbestellmenge, Bezahlung: Barbezahlung, Rechnung, PayPal
* Demoboarde von div. Herstellern (Olimex, ST, ARM-Keil, ETT, Conitex)
* Demoboarde mit ARM (Cortex M)uC von ST, NXP, Energy Micro
* Demoboarde mit ARM Cortex A uC von Olimex
* Keil Debugger/Programmer Ulink ME/2/Pro
* MSP4300 Demoboard
* PIC Demoboarde und Programmer
* AVR Demoboarde und Programmer
* Messgeräte (BMC Messsysteme, Intronix LogicPort)
* Learning Kits
* Mehrsprachig (E, D, F), Preise in SFR / Euro

=== TIGAL KG ===
Homepage: http://www.tigal.com

* Boards und Tools für Embedded-Elektronik
* In Österreich
* Versandkosten ab € 7,00 in Österreich, ab € 10,00 nach Deutschland.
* Preisangaben ohne MWSt. Für Privatkunden kommen 20% österreichische Mehrwertsteuer hinzu.
* U.a. ZeroLogic Logik-Analysatoren.

=== TME (Transfer Multisort Elektronik) ===
Homepage: [http://www.tme.eu/de]

* Firmensitz in Łódź, Polen. Dort nimmt man seit dem 4.9.2012 [http://www.tme.eu/de/pages/News:tme-germany-gmbh-beginnt-eine-selbstandige-tatigkeit.html nach eigener Aussage] keine Bestellungen aus Deutschland mehr an und verweist auf die selbstständige deutsche Tochtergesellschaft. Wo/wie man bei dieser Tochtergesellschaft Bestellungen aufgeben kann ist unklar.
* Ebenso ist unklar, ob die Praxis eines "Strafaufschlags" der polnischen Mutter von 17.6% auf den Bruttopreis für Privatkunden von der deutschen Tochter weitergeführt wird.

=== Trade-Shop / AIR Electronics GmbH ===
Homepage: http://www.trade-shop.de

* Trotz knackiger Sprüche auf der englischen Version der Webseite ("Electronic Components Superstore") eher kleines Angebot elektronischer Bauteile
* 20 Euro Mindestbestellmenge (Stand Februar 2008)
* ab 6,90 Euro Versandkosten (Deutschland, bis 1kg) (Stand Februar 2008)

=== Trenkenchu & Stadler GbR ===
Homepage: http://www.ts-audio.de

* die meisten Artikel sind deutlich teurer als der Marktpreis, es sind jedoch auch Schnäppchen dabei, z.B. HDMI-Kabel

=== TV-Ersatzteile ===
Homepage: http://www.tversatzteile.de

* TV-, Audio-, Video-Ersatzteile, Aktive / Passive Bauteile
* Fernbedienungen Haushaltstechnik

=== UKW-Berichte ===
Homepage: http://www.ukw-berichte.de

* Antennen, Bauteile, Bausätze, Literatur für Amateurfunk
* ansässig in 91081 Baiersdorf

=== Voelkner ===
Homepage: Kein Link, entsprechend der Vorgabe des Betreibers der Voelkner Webseite im Impressum:
<blockquote>voelkner - direkt günstiger
 
wird produziert und betreut von 
Re-In Retail International GmbH 
... 
Eine Verlinkung auf die Website der Firma Re-In Retail International GmbH bedarf einer schriftlichen Genehmigung. </blockquote>

* Großer Teil des Conrad-Programms, identische Nummern, identische Aufkleber auf der Ware, Preise weitgehend identisch oder nur ein paar Cent abweichend, bei bestimmten Artikelgruppen (z.B. Werkzeug) aber auch bis zu 25% billiger
* Versandkosten Deutschland: 4,95€; ab 25€ Warenwert und Sofortüberweisung.de versandkostenfrei / Versandkosten-Flatrate für 15€ pro Jahr
* Versandkosten EU: 9,95€
* Möglichkeit der Versandkostenflatrate (D): Einmalig 14,95€ / gültig für ein Jahr
* Legt jeder Bestellung gleich wieder einen Gutschein über 5€ bei MBW 25€ bei (Flat nur bei häufigen, kleinen Bestellungen sinnvoll); außerdem kommt etwa alle 2-3 Monate selbiger Gutschein + versandkostenfreie Lieferung per Mail, ebenfalls MBW 25€
* Verpackungsqualität wechselnd, mal brauchbar, mal eher Pollin-Niveau. Selbst kleine Bestellungen, die gefahrlos per Brief/Großbrief verschickt werden könnten werden in einem großen Paket versendet.

=== VOTI Webshop ===
Homepage: http://www.voti.nl/shop/catalog.html

* relativ kleines Lieferprogramm
* einige interessante Restposten (Surplus)

* Sitz in Amersfoort, Niederlande

=== Walter elektronik ===
Homepage: http://www.walter-elektronik.de

* Bauteile, Röhren

=== Waschbär Soft 2010 ===
Homepage: http://www.xn--waschbr-soft-2010-vqb.de

* Onlineversandhaus für Unterhaltungselektronik, "Haushaltselektronik", Computer und -zubehör
* keine elektronischen Bauteile

=== Watterott electronic GmbH===
Homepage: http://www.watterott.com

* Distributor für Adafruit, Arduino, BeagleBoard/PandaBoard, Embedded Artists, GHI, Olimex, Parallax, Pololu, Seeed Studio, Solarbotics, SparkFun...
* Entwicklungskits von Atmel, Cypress, Freescale, Microchip, NXP, STM, TI...
* Spezialbauteile von Davicom, FTDI, VLSI, WIZnet...
* Bungard Basismaterial + Chemie
* kein Mindestbestellwert
* Zahlung: Vorkasse, Sofortüberweisung, PayPal, Nachnahme, Kreditkarte (Visa/Mastercard), Rechnung (nur gewerbliche Kunden)
* Versandkosten Dtl. (DHL):
** bis 50 EUR Warenwert: 3,50 Euro
** bis 100 EUR Warenwert: 3,00 Euro
** bis 150 EUR Warenwert: 2,00 Euro
** ab 150 EUR Warenwert: versandkostenfrei
* Versandkosten EU (DHL):
** bis 150 EUR Warenwert: 10,00 Euro
** bis 250 EUR Warenwert: 8,90 Euro
** bis 500 EUR Warenwert: 5,95 Euro
** ab 500 EUR Warenwert: versandkostenfrei
* Schneller, entgegenkommender Service



=== WilTec Wildanger Technik GmbH ===
Homepage: http://shop.wiltec.info

* Aoyue Lötgeräte (Heißluft, Löten, Entlöten), Netzteile, Werkzeuge
* Aoyue Zubehör (Lötspitzen, Heißluftdüsen), Ersatzteile
* Andere, nicht Elektronik-Angebote, wie KFZ-Tuningteile
* Versand. Bei Voranmeldung auch Lagerverkauf.

=== Wüstens frag-jan-zuerst ===
Homepage: http://www.die-wuestens.de/dindex.htm

* Röhrentechnik
* Hochspannungs-Spezialteile

=== WIMO ===
Homepage: http://www.wimo.de

* Große Auswahl an Amateurfunktechnik

=== Zech DG0VE ===
Homepage: http://www.dg0ve.de

* Baugruppen für Amateurfunk

=== Diverse ===
* http://www.chip-flip.com - Europäisches Bauelementesuchsystem, franchised Lieferantensuche, Datenblätter und viele nützliche Informationen
* http://www.ecomponents-store.com/ Elektronische Bauelemente kaufen - Hier finden Sie eine große Auswahl an elektronischen und elektromechanischen Bauelementen von über 40 Herstellern.
* http://www.franchised-distributors.eu/ - Finden Sie Vertragsdistributoren von über 800 Halbleiterherstellern für elektronische und elektromechanische Bauelemente.

TODO: elektronik-fundgrube

==Ebay-Shops==

===Ego-China===
http://stores.ebay.de/Ego-China-Electronics TFTs und LCDs Versand aus China (2-3 Wochen)

===Sure-Electronics===
http://stores.ebay.de/Sure-Electronics Highpower LEDs und Verstärker 
Hat auch einen eigenen Shop: http://www.sureelectronics.net/ 
Versand aus China

===Ether-Deal===
http://stores.ebay.de/ether-deal Unter sonstiges viele versch. Elektronik-teile Versand aus China

===NooElec===
http://stores.ebay.de/NooElec USB-AVR Boards (mega32u2) und rgbled-matrizen Versand aus Kanada

==Messgeräte ==
=== Neue Messgeräte ===

Viele der oben genannten Elektronikversender verkaufen auch Messgeräte. Darüber hinaus gibt es diverse Versender, die sich hauptsächlich oder ausschließlich auf Messgeräte spezialisiert haben. Allerdings verkaufen viele davon nicht an Privat.

==== CalPlus GmbH ====
Homepage: http://www.calplus.de 
Shop: http://www.scopeshop.de

==== Cosinus ComputerMesstechnik ====
Homepage: http://www.cosinus.de

* Nicht an Privat

==== dataTec ====
Homepage: http://www.datatec.de

* Große Auswahl
* <s>(Nicht an Privat)</s> Bestellung von Privat problemlos möglich, Privatpersonen werden laut ABG per Vorkasse beliefert
* Studenten bekommen Rabatt, je nach dem, was bestellt wird
* Umständlicher Bestellvorgang, seitens DataTec teilweise auf dem Postweg -> Es dauert teil sehr lange bis die Ware ankommt
* Sehr freundlicher und kompetenter Service, per eMail als auch telefonisch

==== Elektronik-Kontor Messtechnik GmbH ====
Homepage: http://www.ekomess.de

==== Meilhaus Electronic GmbH ====
Homepage: http://www.meilhaus.de

* Diverse Markenhersteller
* Eigenmarken

==== PinSonne-Elektronik ====
Homepage: http://www.pinsonne-elektronik.de

* Onlineshop
* Sehr kleines Sortiment
* UNI-T, RIGOL und andere asiatische Firmen

==== PK elektronik Poppe GmbH ====
Homepage: http://www.pk-elektronik.de

* U.a. Fluke Distributor.

====Präzitronic Hennig / Messgeräte Chemnitz====
Homepage: http://www.messgeraete-chemnitz.de

* Verkauft explizit auch an Privat.
* Owon
* Selbst übersetzte deutsche Owon-Handbücher
* Fluke
* Extech
* Zusätzlich kleines Angebot an Gebrauchtgeräten

==== ScopeShop Hamburg ====

* Von CalPlus übernommen, siehe [[#CalPlus_GmbH|CalPlus]]

==== SI Scientific Instruments GmbH ====
Homepage: http://www.si-scientific.de (Onlineshop) 
Homepage: http://www.si-gmbh.de (komplettes Programm)

* Onlineshop auf si-scientific.de
* Akzeptiert PayPal

==== SKY Messtechnik GmbH ====
Homepage: http://www.sky-messtechnik.de

* Kein Onlineshop (E-Mail oder Telefon)

==== TESTEC ====
Homepage: http://www.testec.info

* Tastköpfe-Hersteller
* Hameg Vertriebspartner
* B+K Precision Generalimporteur

==== Zeitech ====
Homepage: http://www.zeitech.de/shop/

* Diverses (Rigol, Owon, etc.)

=== Gebrauchte Messgeräte ===

Dieser Abschnitt enthält Anbieter bei denen gebrauchte Messgeräte erhältlich sind.

==== Astro Electronic ====
Homepage: http://www.astro-electronic.de

==== HTB-Elektronik ====
Homepage: http://www.htb-elektronik.com

* Gebrauchte Messgeräte

==== IX Instrumex ====
Homepage: http://www.instrumex.de/index.cgi?User:LANGUAGE=de

* Gebrauchte Messgeräte

==== Christoph Lüders MessTechnik ====
Homepage: http://www.CLMT.de 
Online-Shop: http://www.shop-016.de/shop-CLMT.html 
eBay: http://myworld.ebay.de/c_h_r/

* Hat 2010 die Restbestände von Förtig übernommen

==== mbmt Messtechnik ====
Homepage: http://www.mbmt.com

* Gebrauchte Messgeräte
* Verkauf nur an Gewerbetreibende

==== Rosenkranz Elektronik ====
Homepage: http://www.rosenkranz-elektronik.de 
eBay Shop: http://stores.ebay.de/Rosenkranz-Elektronik-GmbH-Shop

* Gebrauchte Messgeräte
* Auch auf eBay zu finden

==== Helmut-Singer-Elektronik ====
Homepage: http://www.helmut-singer.de

* Gebrauchte Messgeräte
* Verkauf auch an Privat
* An den meisten Samstagen im Jahr auch Lagerverkauf, sonst Versand

==== Sphere ====
Homepage: http://www.sphere.bc.ca 
Messgeräte und Ersatzteile: http://www.sphere.bc.ca/test/index.html

* Gebrauchte Messgeräte
* Ersatzteile
** Besonders bekannt für Tektronix-Ersatzteile

==== Tektronix TekSelect ====
Homepage: http://www.tek.com/Measurement/tekselect/

* Tektronix verkauft selber gebrauchte und überarbeitete Tektronix-Messgeräte unter dem Label ''TekSelect''.
* Original Tektronix-Garantie
* Der Bestellvorgang nervt, man muss Kontaktaufnahme durch einen "Representative" erbeten.

== Siehe auch ==
* [[Platinenhersteller]]
* [[Lokale Elektroniklieferanten]]
* [[Eisenwarenversender]]

== Links ==

* http://www.xs4all.nl/~ganswijk/chipdir/ Suche nach integrierten Schaltkreisen
* http://www.alldatasheet.com Datenblätter

[[Kategorie:Lieferanten]]

AVR-GCC-Tutorial

2012-11-18T14:10:15Z

Mthomas: /* EEPROM */

= Voraussetzungen =

Vorausgesetzt werden Grundkenntnisse der Programmiersprache C. Diese Kenntnisse kann man sich online erarbeiten, z. B. mit dem [http://www.schellong.de/c.htm C Tutorial von Helmut Schellong] ([[C|Liste von C-Tutorials]]). Nicht erforderlich sind Vorkenntnisse in der Programmierung von Mikrocontrollern, weder in Assembler noch in einer anderen Sprache.

= Vorwort =

Dieses Tutorial soll den Einstieg in die Programmierung von Atmel [[AVR]]-Mikrocontrollern in der Programmiersprache [[C]] mit dem freien C-Compiler [[AVR-GCC]] aus der [http://gcc.gnu.org/ GNU Compiler Collection] erleichtern.

In diesem Text wird häufig auf die Standardbibliothek avr-libc verwiesen, für die es eine [http://www.nongnu.org/avr-libc/user-manual/index.html Online-Dokumentation] gibt, in der sich auch viele nützliche Informationen zum Compiler und zur Programmierung von AVR Controllern finden (beim Paket WinAVR gehört die avr-libc Dokumentation zum Lieferumfang und wird mitinstalliert).

Der Compiler und die Standardbibliothek avr-libc werden stetig weiterentwickelt. Einige Unterschiede, die sich im Verlauf der Entwicklung ergeben haben, werden im Haupttext und Anhang zwar erläutert, Anfängern sei jedoch empfohlen, die aktuellen Versionen zu nutzen (für MS-Windows: aktuelle Version des [[WinAVR]]-Pakets; für Linux: siehe Artikel [[AVR und Linux]]).

Das ursprüngliche Tutorial stammt von Christian Schifferle, viele neue Abschnitte und aktuelle Anpassungen von Martin Thomas.

Dieses Tutorial ist in PDF-Form hier erhältlich (nicht immer auf aktuellem Stand):
[[Media:AVR-GCC-Tutorial.pdf]]

== Weiterführende Kapitel ==

Um dieses riesige Tutorial etwas überschaubarer zu gestalten, wurden einige Kapitel ausgelagert, die nicht unmittelbar mit den Grundlagen von avr-gcc in Verbindung stehen. All diese Seiten gehören zur [[:Kategorie:avr-gcc Tutorial]].
: → [[AVR-GCC-Tutorial/Der UART|Der UART]]
: → [[AVR-GCC-Tutorial/Analoge Ein- und Ausgabe|Analoge Ein- und Ausgabe (ADC)]]
: → [[AVR-GCC-Tutorial/Die Timer und Zähler des AVR|Die Timer und Zähler des AVR]]
: → [[AVR-GCC-Tutorial/LCD-Ansteuerung|LCD-Ansteuerung]]
: → [[AVR-GCC-Tutorial/Der Watchdog|Der Watchdog]]
: → [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]]
: → [[AVR-GCC-Tutorial/Alte Quellen|Alte Quellen anpassen]]
: → [[AVR-GCC-Tutorial/Assembler und Inline-Assembler|Assembler und Inline-Assembler]]

= Benötigte Werkzeuge =

Um eigene Programme für AVRs mittels avr-gcc/avr-libc zu erstellen und zu testen, wird folgende Hard- und Software benötigt:

* Platine oder Versuchsaufbau für die Aufnahme eines AVR Controllers, der vom avr-gcc Compiler unterstützt wird (siehe [http://www.nongnu.org/avr-libc/user-manual/index.html#supported_devices Dokumentation der avr-libc] für unterstützte Typen). Dieses Testboard kann durchaus auch selbst gelötet oder auf einem Steckbrett aufgebaut werden. Einige Registerbeschreibungen dieses Tutorials beziehen sich auf den inzwischen veralteten AT90S2313. Der weitaus größte Teil des Textes ist aber für alle Controller der AVR-Familie gültig. Brauchbare Testplattformen sind auch das [[STK500]] und der [[AVR Butterfly]] von Atmel. Weitere Infos findet man in den Artikeln [[AVR#Starterkits|AVR Starterkits]] und [[AVR-Tutorial: Equipment]].

* Der avr-gcc Compiler und die avr-libc. Kostenlos erhältlich für nahezu alle Plattformen und Betriebssysteme. Für MS-Windows im Paket [[WinAVR]]; für Unix/Linux siehe auch Hinweise im Artikel [[AVR-GCC]] und im Artikel [[AVR und Linux]].

* Programmiersoftware und -[[AVR In System Programmer |hardware]] z. B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], Atmel AVRISP, [[AVR-Studio]]).

* Nicht unbedingt erforderlich, aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]]).

* Wer unter Windows und Linux gleichermassen entwickeln will, der sollte sich die [http://www.eclipse.org/ IDE Eclipse for C/C++ Developers] und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin ] ansehen, beide sind unter Windows und Linux einfach zu installieren. Hier gibt es auch einen [[AVR_Eclipse|Artikel AVR Eclipse]] in dieser Wiki. Ebenfalls unter Linux und Windows verfügbar ist die Entwicklungsumgebung [http://www.codeblocks.org/ Code::Blocks] (aktuelle, stabile Versionen sind als Nightly Builds regelmäßig im [http://forums.codeblocks.org/ Forum] verfügbar). Innerhalb dieser Entwicklungsumgebung können ohne die Installation zusätzlicher Plugins "AVR-Projekte" angelegt werden. Für Linux gibt es auch noch das [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=25220&postdays=0&postorder=asc&start=0 KontrollerLab].

= Was tun, wenn's nicht klappt? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder nur die eigenen C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.

* Die [[AVR Checkliste]] durcharbeiten.

* Die '''[http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc]''' lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/'''Frequently Asked Questions''' = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.

* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.

* Das [http://www.mikrocontroller.net/forum/gcc GCC-Forum auf www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.

* Das avr-gcc-Forum bei [http://www.avrfreaks.net AVRfreaks] nach vergleichbaren Problemen absuchen.

* Das [http://lists.gnu.org/archive/html/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.

* Nach Beispielcode suchen. Vor allem im ''Projects''-Bereich von [http://www.avrfreaks.net AVRfreaks] (anmelden).

* Google oder yahoo befragen schadet nie.

* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal). Datenblätter sind auf den [http://www.atmel.com Atmel Webseiten] als pdf-Dateien verfügbar. Das komplette Datenblatt (complete) und nicht die Kurzfassung (summary) verwenden.

* Die Beispielprogramme im [[AVR-Tutorial]] sind zwar in AVR-Assembler verfasst, Erläuterungen und Vorgehensweisen sind aber auch auf C-Programme übertragbar.

* Einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei möglichst viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode oder besser ein [http://www.mikrocontroller.net/topic/72767#598986 Testprojekt] mit allen notwendigen Dateien, um das Problem nachzuvollziehen, sowie genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z. B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: '''[http://www.tty1.net/smart-questions_de.html "Wie man Fragen richtig stellt"]'''.

= Erzeugen von Maschinencode =

Aus dem C-Quellcode erzeugt der avr-gcc Compiler (zusammen mit Hilfsprogrammen wie z. B. Präprozessor, Assembler und Linker) Maschinencode für den AVR-Controller. Üblicherweise liegt dieser Code dann im Intel Hex-Format vor ("Hex-Datei"). Die Programmiersoftware (z. B. [[AVRDUDE]], PonyProg oder AVRStudio/STK500-plugin) liest diese Datei ein und überträgt die enthaltene Information (den Maschinencode) in den Speicher des Controllers. Im Prinzip sind also "nur" der avr-gcc-Compiler (und wenige Hilfsprogramme) mit den "richtigen" Optionen aufzurufen, um aus C-Code eine "Hex-Datei" zu erzeugen. Grundsätzlich stehen dazu zwei verschiedene Ansätze zur Verfügung:

* Die Verwendung einer integrierten Entwicklungsumgebung (IDE = '''I'''ntegrated '''D'''evelopment '''E'''nvironment), bei der alle Einstellungen z. B. in Dialogboxen durchgeführt werden können. Unter Anderem kann AVRStudio ab Version 4.12 (kostenlos auf [http://www.atmel.com/ atmel.com]) zusammen mit WinAVR als integrierte Entwicklungsumgebung für den Compiler avr-gcc genutzt werden (dazu müssen AVRStudio und WinAVR auf dem Rechner installiert sein). Weitere IDEs (ohne Anspruch auf Vollständigkeit): [http://www.eclipse.org/ Eclipse for C/C++ Developers] (d.h. inkl. CDT) und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin] (für diverse Plattformen, u.a. Linux und MS Windows, IDE und Plugin kostenlos), [http://sourceforge.net/projects/kontrollerlab KontrollerLab] (Linux/KDE, kostenlos). [http://www.atmanecl.com/EnglishSite/SoftwareEnglish.htm AtmanAvr] (MS Windows, relativ günstig), KamAVR (MS-Windows, kostenlos, wird augenscheinlich nicht mehr weiterentwickelt), [http://www.amctools.com/vmlab.htm VMLab] (MS Windows, ab Version 3.12 ebenfalls kostenlos). Integrierte Entwicklungsumgebungen unterscheiden sich stark in Ihrer Bedienung und stehen auch nicht für alle Plattformen zur Verfügung, auf denen der Compiler ausführbar ist (z. B. AVRStudio nur für MS-Windows). Zur Anwendung des avr-gcc Compilers mit IDEs sei hier auf deren Dokumentation verwiesen.

* Die Nutzung des Programms make mit passenden Makefiles. In den folgenden Abschnitten wird die Generierung von Maschinencode für einen AVR ("hex-Datei") aus C-Quellcode ("c-Dateien") anhand von "make" und den "Makefiles" näher erläutert. Viele der darin beschriebenen Optionen findet man auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio (AVRStudio generiert ein makefile in einem Unterverzeichnis des Projektverzeichnisses).

Beim Wechsel vom makefile-Ansatz nach WinAVR-Vorlage zu AVRStudio ist darauf zu achten, dass AVRStudio (Stand: AVRStudio Version 4.13) bei einem neuen Projekt die Optimierungsoption (vgl. Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|AVR-GCC-Tutorial/Exkurs: Makefiles]], typisch: -Os) nicht einstellt und die mathematische Bibliothek der avr-libc (libm.a, Linker-Option -lm) nicht einbindet. (Hinweis: Bei Version 4.16 wird beides bereits gesetzt). Beides ist Standard bei Verwendung von makefiles nach WinAVR-Vorlage und sollte daher auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio "manuell" eingestellt werden, um auch mit AVRStudio kompakten Code zu erzeugen.

= Einführungsbeispiel =

Zum Einstieg ein kleines Beispiel, an dem die Nutzung des Compilers und der Hilfsprogramme (der sogenannten ''Toolchain'') demonstriert wird. Detaillierte Erläuterungen folgen in den weiteren Abschnitten dieses Tutorials.

Das Programm soll auf einem AVR Mikrocontroller einige Ausgänge ein- und andere ausschalten. Das Beispiel ist für einen ATmega16 programmiert ([http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf Datenblatt]), kann aber sinngemäß für andere Controller der AVR-Familie modifiziert werden.

Ein kurzes Wort zur Hardware: Bei diesem Programm werden alle Pins von PORTB auf Ausgang gesetzt, und einige davon werden auf HIGH andere auf LOW gesetzt. Das kann je nach angeschlossener Hardware an diesen Pins kritisch sein. Am ungefährlichsten ist es, wenn nichts an den Pins angeschlossen ist und man die Funktion des Programmes durch eine Spannungsmessung mit einem Multimeter kontrolliert. Die Spannung wird dabei zwischen GND-Pin und den einzelnen Pins von PORTB gemessen.

Zunächst der Quellcode der Anwendung, der in einer Text-Datei mit dem Namen ''main.c'' abgespeichert wird.

<c>
/* Alle Zeichen zwischen Schrägstrich-Stern
und Stern-Schrägstrich sind Kommentare */

// Zeilenkommentare sind ebenfalls möglich
// alle auf die beiden Schrägstriche folgenden
// Zeichen einer Zeile sind Kommentar

#include <avr/io.h> // (1)

int main (void) { // (2)

DDRB = 0xFF; // (3)
PORTB = 0x03; // (4)

while(1) { // (5)
/* "leere" Schleife*/ // (6)
} // (7)

/* wird nie erreicht */
return 0; // (8)
}
</c>

# In dieser Zeile wird eine sogenannte Header-Datei eingebunden. In <code>avr/io.h</code> sind die Registernamen definiert, die im späteren Verlauf genutzt werden. Auch unter Windows wird ein <code>/</code> zur Kennzeichnung von Unterverzeichnissen in Include-Dateinamen verwendet und kein <code>\</code>.
# Hier beginnt das eigentliche Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion <code>main</code>.
# Die Anschlüsse eines AVR (Pins) werden zu Blöcken zusammengefasst, einen solchen Block bezeichnet man als Port. Beim ATmega16 hat jeder Port 8 Anschlüsse, bei kleineren AVRs können einem Port auch weniger als 8 Anschlüsse zugeordnet sein. Da per Definition (Datenblatt) alle gesetzten Bits in einem Datenrichtungsregister den entsprechenden Anschluss auf Ausgang schalten, werden mit DDRB=0xff alle Anschlüsse des Ports B als Ausgänge eingestellt.
# Die den ersten beiden Bits des Ports zugeordneten Anschlüsse (PB0 und PB1) werden 1, alle anderen Anschlüsse des Ports B (PB2-PB7) zu 0. Aktivierte Ausgänge (logisch 1 oder "high") liegen auf Betriebsspannung (VCC, meist 5 Volt), nicht aktivierte Ausgänge führen 0 Volt (GND, Bezugspotential). Es ist sinnvoll, sich möglichst frühzeitig eine alternative Schreibweise beizubringen, die wegen der leichteren Überprüfbarkeit und Portierbarkeit oft im weiteren Tutorial und in Forenbeiträgen benutzt wird. Die Zuordnung sieht in diesem Fall so aus, Näheres dazu im Artikel [[Bitmanipulation]]:<c>PORTB = (1<<PB1) | (1<<PB0);</c>
# ist der Beginn der sogenannte ''Hauptschleife'' (main-loop). Dies ist eine Endlosschleife, welche kontinuierlich wiederkehrende Befehle enthält.
# In diesem Beispiel ist die Hauptschleife leer. Der Controller durchläuft die Schleife immer wieder, ohne dass etwas passiert. Eine solche Schleife ist notwendig, da es auf dem Controller kein Betriebssystem gibt, das nach Beendigung des Programmes die Kontrolle übernehmen könnte. Ohne diese Schleife kehrt das Programm aus <code>main</code> zurück, alle Interrupts werden deaktiviert und eine Endlosschleife betreten.
# Ende der Hauptschleife und Sprung zur passenden, öffnenden Klammer, also zu 5.
# ist das Programmende. Die Zeile ist nur aus Gründen der C-Kompatibilität enthalten: <c>int main(void)</c> besagt, dass die Funktion einen int-Wert zurückgibt. Die Anweisung wird aber nicht erreicht, da das Programm die Hauptschleife nie verlässt.

Um diesen Quellcode in ein lauffähiges Programm zu übersetzen, wird hier ein Makefile genutzt. Das verwendete Makefile findet sich auf der Seite [[Beispiel Makefile]] und basiert auf der Vorlage, die in WinAVR mitgeliefert wird und wurde bereits angepasst (Controllertyp ATmega16). Man kann das Makefile bearbeiten und an andere Controller anpassen oder sich mit dem Programm MFile menügesteuert ein Makefile "zusammenklicken". Das Makefile speichert man unter dem Namen <code>Makefile</code> (ohne Endung) im selben Verzeichnis, in dem auch die Datei <code>main.c</code> mit dem Programmcode abgelegt ist. Detailliertere Erklärungen zur Funktion von Makefiles finden sich im Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]].

<pre>
D:\beispiel>dir

Verzeichnis von D:\beispiel

28.11.2006 22:53 <DIR> .
28.11.2006 22:53 <DIR> ..
28.11.2006 20:06 118 main.c
28.11.2006 20:03 16.810 Makefile
2 Datei(en) 16.928 Bytes
</pre>

Nun gibt man ''make all'' ein. Falls das mit WinAVR installierte Programmers Notepad genutzt wird, gibt es dazu einen Menüpunkt im Tools Menü. Sind alle Einstellungen korrekt, entsteht eine Datei <code>main.hex</code>, in welcher der Code für den AVR enthalten ist.
<pre>
D:\beispiel>make all

-------- begin --------
avr-gcc (GCC) 3.4.6
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Compiling C: main.c
avr-gcc -c -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -f
unsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef
-Wa,-adhlns=obj/main.lst -std=gnu99 -Wundef -MD -MP -MF .dep/main.o.d main.c -
o obj/main.o

Linking: main.elf
avr-gcc -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -funs
igned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef -W
a,-adhlns=obj/main.o -std=gnu99 -Wundef -MD -MP -MF .dep/main.elf.d obj/main.o
--output main.elf -Wl,-Map=main.map,--cref -lm

Creating load file for Flash: main.hex
avr-objcopy -O ihex -R .eeprom main.elf main.hex
</pre>

Der Inhalt der hex-Datei kann nun zum Controller übertragen werden. Dies kann z. B. über In-System-Programming ([[ISP]]) erfolgen, das im [[AVR-Tutorial: Equipment]] beschrieben ist. Makefiles nach der WinAVR/MFile-Vorlage sind für die Nutzung des Programms [[AVRDUDE]] vorbereitet. Wenn man den Typ und Anschluss des Programmiergerätes richtig eingestellt hat, kann mit ''make program'' die Übertragung mittels AVRDUDE gestartet werden. Jede andere Software, die hex-Dateien lesen und zu einem AVR übertragen kann<ref>z. B. [[Pony-Prog_Tutorial|Ponyprog]], yapp, AVRStudio</ref>, kann natürlich ebenfalls genutzt werden.

Startet man nun den Controller (Reset-Taster oder Stromzufuhr aus/an), werden vom Programm die Anschlüsse PB0 und PB1 auf 1 gesetzt. Man kann mit einem Messgerät nun an diesem Anschluss die Betriebsspannung messen oder eine [[LED]] leuchten lassen (Anode an den Pin, Vorwiderstand nicht vergessen). An den Anschlüssen PB2-PB7 misst man 0 Volt. Eine mit der Anode mit einem dieser Anschlüsse verbundene LED leuchtet nicht.

= Ganzzahlige Datentypen (Integer) =

Bei der Programmierung von Mikrokontrollern ist die Definition einiger ganzzahliger Datentypen sinnvoll, an denen eindeutig die Bit-Länge abgelesen werden kann.

Standardisierte Datentypen werden in der Header-Datei <code>stdint.h</code> definiert, die folgendermaßen eingebunden werden kann:
<c>#include <stdint.h></c>

{| {{Tabelle}}
|+ '''int-Typen aus <code>stdint.h</code> (C99)'''  
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenbehaftete int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>int8_t</code> ||align="right"| 8 || −128 ⋯ 127 || −27 ⋯ 27−1 || <code>signed char</code>
|-
|<code>int16_t</code> ||align="right"| 16 || −32768 ⋯ 32767 || −215 ⋯ 215−1 || <code>signed short</code>, <code>signed int</code>
|-
|<code>int32_t</code> ||align="right"| 32 || −2147483648 ⋯ 2147483647 || −231 ⋯ 231−1 || <code>signed long</code>
|-
|<code>int64_t</code> ||align="right"| 64 || −9223372036854775808 ⋯ 9223372036854775807 || −263 ⋯ 263−1 || <code>signed long long</code>
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenlose int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>uint8_t</code> ||align="right"| 8 || 0 ⋯ 255 || 0 ⋯ 28−1 || <code>unsigned char</code>
|-
|<code>uint16_t</code> ||align="right"| 16 || 0 ⋯ 65535 || 0 ⋯ 216−1 || <code>unsigned short</code>, <code>unsigned int</code>
|-
|<code>uint32_t</code> ||align="right"| 32 || 0 ⋯ 4294967295 || 0 ⋯ 232−1 || <code>unsigned long</code>
|-
|<code>uint64_t</code> ||align="right"| 64 || 0 ⋯ 18446744073709551615 || 0 ⋯ 264−1 || <code>unsigned long long</code>
|}

Neben den Typen gibt es auch Makros für die Bereichsgrenzen wie <code>INT8_MIN</code> oder <code>UINT16_MAX</code>. Siehe dazu auch: [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdint.html Dokumentation der avr-libc: Standard Integer Types].

= Bitfelder =

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bits breit ist.

Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in eine einzelne Bytevariable zusammenfassen und (fast) wie
8 einzelne Variablen ansprechen können. Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<c>
struct {
unsigned bStatus_1:1; // 1 Bit für bStatus_1
unsigned bStatus_2:1; // 1 Bit für bStatus_2
unsigned bNochNBit:1; // Und hier noch mal ein Bit
unsigned b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</c>

Der Zugriff auf ein solches Feld erfolgt nun, wie beim Strukturzugriff bekannt,
über den Punkt- oder den Dereferenzierungs-Operator:

<c>
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</c>

Bitfelder sparen Platz im RAM, zu Lasten von Platz im Flash, verschlechtern aber unter Umständen die Les- und Wartbarkeit des Codes. Anfängern wird deshalb geraten, ein "ganzes" Byte (uint8_t) zu nutzen, auch wenn nur ein Bitwert gespeichert werden soll.

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

[[Image:Sequentielle Programme.gif|left]]
Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat. Es wird hier nach dem sogenannten EVA-Prinzip gehandelt. EVA steht für "Eingabe, Verarbeitung, Ausgabe".
{{Absatz}}

== Interruptgesteuerter Programmablauf ==

[[Image:Interrupt Programme.gif|left]]
Bei dieser Methode werden beim Programmstart zuerst die gewünschten Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher Dinge erledigt werden können, welche nicht zeitkritisch sind. Wenn ein Interrupt ausgelöst wird, so wird automatisch die zugeordnete Interruptfunktion ausgeführt.
{{Absatz}}

= Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heißt, das Programm kann die
Inhalte der Register sowohl auslesen als auch beschreiben.

Register haben einen besonderen Stellenwert bei den AVR Controllern. Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir die 8-Bit Register.

Einzelne Register sind bei allen AVRs vorhanden, andere wiederum nur bei bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff auf den UART notwendig sind, selbstverständlich nur bei denjenigen Modellen vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden AVR-Typen definiert. Dazu muss man den Namen der controllerspezifischen Headerdatei nicht kennen. Es reicht aus, die allgemeine Headerdatei ''avr/io.h'' einzubinden:

<c>
#include <avr/io.h>
</c>

Ist im Makefile der MCU-Typ z. B. mit dem Inhalt atmega8 definiert (und wird somit per -mmcu=atmega8 an den Compiler übergeben), wird beim Einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit den Register-Definitionen für den ATmega8 eingelesen.


Intern wird diese "Automatik" wie folgt realisiert: Der Controllertyp wird dem Compiler als Parameter übergeben (vgl. ''avr-gcc -c -mmcu=atmega16 [...]'' im Einführungsbeispiel). Wird ein Makefile nach der WinAVR/mfile-Vorlage verwendet, setzt man die Variable ''MCU'', der Inhalt dieser Variable wird dann an passender Stelle für die Compilerparameter verwendet. Der Compiler definiert intern eine dem mmcu-Parameter zugeordnete "Variable" (genauer: ein Makro) mit dem Namen des Controllers, vorangestelltem ''__AVR_'' und angehängten Unterstrichen (z. B. wird bei ''-mmcu=atmega16'' das Makro ''__AVR_ATmega16__'' definiert). Beim Einbinden der Header-Datei ''avr/io.h'' wird geprüft, ob das jeweilige Makro definiert ist und die zum Controller passende Definitionsdatei eingelesen. Zur Veranschaulichung einige Ausschnitte aus einem Makefile:

<pre>
[...]
# MCU Type ("name") setzen:
MCU = atmega16
[...]

[...]
## Verwendung des Inhalts von MCU (hier atmega16) fuer die
## Compiler- und Assembler-Parameter
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
[...]

[...]
## Aufruf des Compilers:
## mit den Parametern ($(ALL_CFLAGS) ist -mmcu=$(MCU)[...] = -mmcu=atmega16[...]
$(OBJDIR)/%.o : %.c
@echo
@echo $(MSG_COMPILING) $<
$(CC) -c $(ALL_CFLAGS) $< -o $@
[...]
</pre>

Da --mmcu=atmega16 übergeben wurde, wird __AVR_ATmega16__ definiert und kann in avr/io.h zur Fallunterscheidung genutzt werden:

<c>
// avr/io.h
// (bei WinAVR-Standardinstallation in C:\WinAVR\avr\include\avr)
[...]
#if defined (__AVR_AT94K__)
# include <avr/ioat94k.h>
// [...]
#elif defined (__AVR_ATmega16__)
// da __AVR_ATmega16__ definiert ist, wird avr/iom16.h eingebunden:
# include <avr/iom16.h>
// [...]
#else
# if !defined(__COMPILING_AVR_LIBC__)
# warning "device type not defined"
# endif
#endif
</c>

Die Beispiele in den folgenden Abschnitten demonstrieren den Zugriff auf Register anhand der Register für I/O-Ports (PORTx, DDRx, PINx), die Vorgehensweise ist jedoch für alle Register (z. B. die des UART, ADC, SPI) analog.

== Schreiben in Register ==

Zum Schreiben kann man Register einfach wie eine Variable setzen.<ref>In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Schreibzugriff über die Funktion outp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt, outp() ist nicht mehr erforderlich.</ref>

Beispiel:

<c>
#include <avr/io.h>

int main()
{
/* Setzt das Richtungsregister des Ports A auf 0xff
(alle Pins als Ausgang, vgl. Abschnitt Zugriff auf Ports): */
DDRA = 0xff;

/* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low": */
PORTA = 0x03;

// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
DDRB = 0x1F; /* direkte Zuweisung - unübersichtlich */

/* Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
aber übersichtlicher und selbsterklärend: */
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);

while (1);
}
</c>

Die ausführliche Schreibweise sollte bevorzugt verwendet werden, da dadurch die Zuweisungen selbsterklärend sind und somit der Code leichter nachvollzogen werden kann. Atmel verwendet sie auch bei Beispielen in Datenblätten und in den allermeisten Quellcodes zu Application-Notes. Mehr zu der Schreibweise mit "|" und "<<" findet man unter [[Bitmanipulation]].

Der gcc C-Compiler unterstützt ab Version 4.3.0 Konstanten im Binärformat, z. B. DDRB = 0b00011111. Diese Schreibweise ist jedoch nur in GNU-C verfügbar und nicht in ISO-C definiert. Man sollte sie daher nicht verwenden, wenn Code mit anderen ausgetauscht oder mit anderen Compilern bzw. älteren Versionen des gcc genutzt werden soll.

== Verändern von Registerinhalten ==

Einzelne Bits setzt und löscht man "Standard-C-konform" mittels logischer (Bit-) Operationen.

<c>
x |= (1 << Bitnummer); // Hiermit wird ein Bit in x gesetzt
x &= ~(1 << Bitnummer); // Hiermit wird ein Bit in x geloescht
</c>

Es wird jeweils nur der Zustand des angegebenen Bits geändert, der vorherige Zustand der anderen Bits bleibt erhalten.

Beispiel:
<c>
#include <avr/io.h>
...
#define MEINBIT 2
...
PORTA |= (1 << MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1 << MEINBIT); /* loescht Bit 2 an PortA */
</c>

Mit dieser Methode lassen sich auch mehrere Bits eines Registers gleichzeitig setzen und löschen.

Beispiel:
<c>
#include <avr/io.h>
...
DDRA &= ~( (1<<PA0) | (1<<PA3) ); /* PA0 und PA3 als Eingaenge */
PORTA |= ( (1<<PA0) | (1<<PA3) ); /* Interne Pull-Up fuer beide einschalten */
</c>

Bei bestimmten AVR Registern mit Bits, die durch Beschreiben mit einer logischen 1 gelöscht werden, muss eine absolute Zuweisung benutzt werden. Ein ODER löscht in diesen Registern ALLE gesetzten Bits!

Beispiel:
<c>
#include <avr/io.h>
...
TIFR2 = (1<<OCF2A); // Nur Bit OCF2A löschen
</c>

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind nicht mehr erforderlich.

Siehe auch:
* [[Bitmanipulation]]
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

== Lesen aus Registern ==

Zum Lesen kann man auf Register einfach wie auf eine Variable zugreifen. In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Lesezugriff über die Funktion inp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt und inp() ist nicht mehr erforderlich.

Beispiel:

<c>
#include <avr/io.h>
#include <stdint.h>

uint8_t foo;

//...

int main(void)
{
/* kopiert den Status der Eingabepins an PortB
in die Variable foo: */
foo = PINB;
//...
}
</c>

Die Abfrage der Zustände von Bits erfolgt durch Einlesen des gesamten Registerinhalts und ausblenden der Bits deren Zustand nicht von Interesse ist. Einige Beispiele zum Prüfen ob Bits gesetzt oder gelöscht sind:

<c>
#define MEINBIT0 0
#define MEINBIT2 2

uint8_t i;

extern test1();

// Funkion test1 aufrufen, wenn Bit 0 in Register PINA gesetzt (1) ist
i = PINA; // Inhalt in Arbeitsvariable
i = i & 0x01; // alle Bits bis auf Bit 0 ausblenden (bitweise und)
// falls das Bit gesetzt war, hat i den Inhalt 1
if ( i != 0 ) { // Ergebnis ungleich 0 (wahr)?
test1(); // dann muss Bit 0 in i gesetzt sein -> Funktion aufrufen
}
// verkürzt:
if ( ( PINA & 0x01 ) != 0 ) {
test1();
}
// nochmals verkürzt:
if ( PINA & 0x01 ) {
test1();
}
// mit definierter Bitnummer:
if ( PINA & ( 1 << MEINBIT0 ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 und/oder Bit 2 gesetzt ist. (Bit 0 und 2 also Wert 5)
// (Bedenke: Bit 0 hat Wert 1, Bit 1 hat Wert 2 und Bit 2 hat Wert 4)
if ( PINA & 0x05 ) {
test1(); // Vergleich <> 0 (wahr), also mindestens eines der Bits gesetzt
}
// mit definierten Bitnummern:
if ( PINA & ( ( 1 << MEINBIT0 ) | ( 1 << MEINBIT2 ) ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 und Bit 2 gesetzt sind
if ( ( PINA & 0x05 ) == 0x05 ) { // nur wahr, wenn beide Bits gesetzt
test1();
}

// Funktion test2() aufrufen, wenn Bit 0 gelöscht (0) ist
i = PINA; // einlesen in temporäre Variable
i = i & 0x01; // maskieren von Bit 0
if ( i == 0 ) { // Vergleich ist wahr, wenn Bit 0 nicht gesetzt ist
test2();
}
// analog mit not-Operator
if ( !i ) {
test2();
}
// nochmals verkürzt:
if ( !( PINA & 0x01 ) ) {
test2();
}
</c>

== Warten auf einen bestimmten Zustand ==

Es gibt in der Bibliothek avr-libc Funktionen, die warten, bis ein bestimmter Zustand eines Bits erreicht ist. Es ist allerdings normalerweise eine eher unschöne Programmiertechnik, da in diesen Funktionen "blockierend" gewartet wird. Der Programmablauf bleibt also an dieser Stelle stehen, bis das maskierte Ereignis erfolgt ist. Setzt man den [[Watchdog]] ein, muss man darauf achten, dass dieser auch noch getriggert wird (Zurücksetzen des Watchdogtimers).

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits gesetzt ist, wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT PA2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1 << WARTEBIT)) ) {}
...
</c>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits gelöscht ist, wird die Funktion sofort wieder verlassen.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT PB4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// gesetzt (1) ist
while ( WARTEPIN & (1<<WARTEBIT) ) {}
...
</c>

Universeller und auch auf andere Plattformen besser übertragbar ist die Verwendung von C-Standardoperationen.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]

== 16-Bit Register (ADC, ICR1, OCR1x, TCNT1, UBRR) ==

Einige der Portregister in den AVR-Controllern sind 16 Bit breit. Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (Low-Byte) und "H" (High-Byte) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese Register kann dann direkt zugegriffen werden. Dies ist zum Beispiel der Fall für Register wie ADC oder TCNT1.
<c>
#include <avr/io.h>
...
uint16_t foo;

/* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
foo = ADC;
</c>

Bei anderen Registern, wie zum Beispiel Baudraten-Register, liegen High- und Low-Teil nicht direkt nebeneinander im SFR-Bereich, so dass ein 16-Bit Zugriff nicht möglich ist und der Zugriff zusammengebastelt werden muss:

<c>
#include <avr/io.h>

#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

...
uint16_t baud = F_CPU / (UART_BAUD_RATE * 16L) -1;

UBRRH = (uint8_t) (baud >> 8);
UBRRL = (uint8_t) baud;
...
</c>

Bei einigen AVR-Typen wie ATmega8 oder ATmega16 teilen sich UBRRH und UCSRC die gleiche Speicher-Adresse. Damit der AVR trotzdem zwischen den beiden Registern unterscheiden kann, bestimmt das Bit7 (URSEL), welches Register tatsächlich beschrieben werden soll. ''1000 0011'' (0x83) adressiert demnach UCSRC und übergibt den Wert ''3''. Und ''0000 0011'' (0x3) adressiert UBRRH und übergibt ebenfalls den Wert ''3''.

Speziell bei den 16-Bit-Timern und auch beim ADC ist es bei allen Zugriffen auf Datenregister erforderlich, dass diese Daten synchronisiert sind. Wenn z. B. bei einem 16-Bit-Timer das High-Byte des Zählregisters gelesen wurde und vor dem Lesezugriff auf das Low-Byte ein Überlauf des Low-Bytes stattfindet, erhält man einen völlig unsinnigen Wert. Auch die Compare-Register müssen synchron geschrieben werden, da es ansonsten zu unerwünschten Compare-Ereignissen kommen kann.

Beim ADC besteht das Problem darin, dass zwischen den Zugriffen auf die beiden Teilregister eine Wandlung beendet werden kann und der ADC ein neues Ergebnis in ADCL und ADCH schreiben will, wodurch High- und Low-Byte nicht zusammenpassen.

Um diese Datenmüllproduktion zu verhindern, gibt es in beiden Fällen eine Synchronisation, die jeweils durch den Zugriff auf das Low-Byte ausgelöst wird:
* Bei den Timer-Registern (das gilt für alle TCNT-, OCR- und ICR-Register bei den 16-Bit-Timern) wird bei einem ''Lesezugriff'' auf das Low-Byte automatisch das High-Byte in ein temporäres Register, das ansonsten nach außen nicht sichtbar ist, geschoben. Greift man nun ''anschließend'' auf das High-Byte zu, dann wird eben dieses temporäre Register gelesen.
* Bei einem ''Schreibzugriff'' auf eines der genannten Register wird das High-Byte in besagtem temporären Register zwischengespeichert und erst beim Schreiben des Low-Bytes werden ''beide'' gleichzeitig in das eigentliche Register übernommen.

Das bedeutet für die Reihenfolge:
* Lesezugriff: Erst Low-Byte, dann High-Byte
* Schreibzugriff: Erst High-Byte, dann Low-Byte

Des weiteren ist zu beachten, dass es für all diese 16-Bit-Register nur ein einziges temporäres Register gibt, so dass das Auftreten eines Interrupts, in dessen Handler ein solches Register manipuliert wird, bei einem durch ihn unterbrochenen Zugriff i.d.R. zu Datenmüll führt. 16-Bit-Zugriffe sind generell nicht atomar! Wenn mit Interrupts gearbeitet wird, kann es erforderlich sein, vor einem solchen Zugriff auf ein 16-Bit-Register die Interrupt-Bearbeitung zu deaktivieren.

Beim ADC-Datenregister ADCH/ADCL ist die Synchronisierung anders gelöst. Hier wird beim Lesezugriff (ADCH/ADCL sind logischerweise read-only) auf das Low-Byte ADCL beide Teilregister für Zugriffe seitens des ADC so lange gesperrt, bis das High-Byte ADCH ausgelesen wurde. Dadurch kann der ADC nach einem Zugriff auf ADCL keinen neuen Wert in ADCH/ADCL ablegen, bis ADCH gelesen wurde. Ergebnisse von Wandlungen, die zwischen einem Zugriff auf ADCL und ADCH beendet werden, gehen verloren!

Nach einem Zugriff auf ADCL muss grundsätzlich ADCH gelesen werden!

In beiden Fällen – also sowohl bei den Timern als auch beim ADC – werden vom C-Compiler 16-Bit Pseudo-Register zur Verfügung gestellt (z. B. TCNT1H/TCNT1L → TCNT1, ADCH/ADCL → ADC bzw. ADCW), bei deren Verwendung der Compiler automatisch die richtige Zugriffsreihenfolge regelt. In C-Programmen sollten grundsätzlich diese 16-Bit-Register verwendet werden! Sollte trotzdem ein Zugriff auf ein Teilregister erforderlich sein, sind obige Angaben zu berücksichtigen.

Es ist darauf zu achten, dass auch ein Zugriff auf die 16-Bit-Register vom Compiler in zwei 8-Bit-Zugriffe aufgeteilt wird und dementsprechend genauso nicht-atomar ist wie die Einzelzugriffe. Auch hier gilt, dass u.U. die Interrupt-Bearbeitung gesperrt werden muss, um Datenmüll zu vermeiden.

Beim ADC gibt es für den Fall, dass eine Auflösung von 8 Bit ausreicht, die Möglichkeit, das Ergebnis "linksbündig" in ADCH/ADCL auszurichten, so dass die relevanten 8 MSB in ADCH stehen. In diesem Fall muss bzw. sollte nur ADCH ausgelesen werden.

ADC und ADCW sind unterschiedliche Bezeichner für das selbe Registerpaar. Üblicherweise kann man in C-Programmen ADC verwenden, was analog zu den anderen 16-Bit-Registern benannt ist. ADCW (ADC Word) existiert nur deshalb, weil die Headerdateien auch für Assembler vorgesehen sind und es bereits einen Assembler-Befehl namens ''adc'' gibt.

Im Umgang mit 16-Bit Registern siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8
* Datenblatt Abschnitt ''Accessing 16-bit Registers''

== IO-Register als Parameter und Variablen ==

Um Register als Parameter für eigene Funktionen übergeben zu können, muss man sie als einen volatile uint8_t Pointer übergeben. Zum Beispiel:

<c>
#include <avr/io.h>
#include <util/delay.h>

uint8_t key_pressed (volatile uint8_t *inputreg, uint8_t inputbit)
{
static uint8_t last_state = 0;

if (last_state == (*inputreg & (1<<inputbit)))
return 0; /* keine Änderung */

/* Wenn doch, warten bis etwaiges Prellen vorbei ist: */
_delay_ms(20);

/* Zustand für nächsten Aufruf merken: */
last_state = *inputreg & (1<<inputbit);

/* und den entprellten Tastendruck zurückgeben: */
return *inputreg & (1<<inputbit);
}

/* Beispiel für einen Funktionsaufruf: */

void foo (void)
{
uint8_t i = key_pressed (&PINB, PB1);
}
</c>

Ein Aufruf der Funktion mit call by value würde Folgendes bewirken: Beim Funktionseintritt wird nur eine Kopie des momentanen Portzustandes angefertigt, die sich unabhängig vom tatsächlichen Zustand das Ports nicht mehr ändert, womit die Funktion wirkungslos wäre. Die Übergabe eines Zeigers wäre die Lösung, wenn der Compiler nicht optimieren würde. Denn dadurch wird im Programm nicht von der Hardware gelesen, sondern wieder nur von einem Abbild im Speicher. Das Ergebnis wäre das gleiche wie oben. Mit dem Schlüsselwort volatile sagt man nun dem Compiler, dass die entsprechende Variable entweder durch andere Softwareroutinen (Interrupts) oder durch die Hardware verändert werden kann.

Siehe auch: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass avr-libc FAQ: "How do I pass an IO port as a parameter to a function?"]

= Zugriff auf IO-Ports =

Jeder AVR implementiert eine unterschiedliche Menge an GPIO-Registern
(GPIO - General Purpose Input/Output). Diese Register dienen dazu:
* einzustellen welche der Anschlüsse ("Beinchen") des Controllers als Ein- oder Ausgänge dienen
* bei Ausgängen deren Zustand festzulegen
* bei Eingängen deren Zustand zu erfassen

Mittels GPIO werden digitale Zustände gesetzt und erfasst, d.h. die Spannung an einem Ausgang wird ein- oder ausgeschaltet und an einem Eingang wird erfasst, ob die anliegende Spannung über oder unter einem bestimmten Schwellwert liegt. Im Datenblatt Abschnitt Electrical Characteristics/DC Characteristics finden sich die Spannungswerte (V_OL, V_OH für Ausgänge, V_IL, V_IH für Eingänge).

Die Verarbeitung von analogen Eingangswerten und die Ausgabe von Analogwerten wird in Kapitel [[AVR-GCC-Tutorial#Analoge_Ein-_und_Ausgabe|Analoge Ein- und Ausgabe]] behandelt.

Die physischen Ein- und Ausgänge werden bei AVR-Controllern zu logischen Ports gruppiert.

Alle Ports werden über Register gesteuert. Dazu sind jedem Port 3 Register zugeordnet:

{| class="wikitable"
|-
! DDRx
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (abhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
! PINx
| Eingangsadresse für Port'''x'''.
Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der als Eingang definierten Portpins. Bit 1 wenn Pin "high", Bit 0 wenn Portpin low.
|-
! PORTx
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Bei Pins, die mittels DDRx auf Eingang geschaltet wurden, können über PORTx
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|}

Die folgenden Beispiele gehen von einem AVR aus, der sowohl Port A als auch Port B besitzt. Sie müssen für andere AVRs (zum Beispiel ATmega8/48/88/168) entsprechend angepasst werden.

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.

Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Beispiel:
Angenommen am Port B sollen die Pins 0 bis 4 als Ausgänge definiert werden, die noch verbleibenden Pins 5 bis 7 sollen als Eingänge fungieren. Dazu ist es daher notwendig, im für das Port B zuständigen Datenrichtungsregister DDRB folgende Bitkonfiguration einzutragen

+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |

In C liest sich das dann so:

<c>
// in io.h wird u.a. DDRB definiert:
#include <avr/io.h>

int main()
{
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
// direkte Zuweisung - standardkonform */
DDRB = 0x1F; /*

// übersichtliche Alternative - Binärschreibweise, aber kein ISO-C
DDRB = 0b00011111;

// Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
// aber übersichtlicher und selbsterklärend:
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);
</c>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet. Weitere Beispiele:

<c>
// Alle Pins des Ports B als Ausgang definieren:
DDRB = 0xff;
// Pin0 wieder auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~(1 << DDB0);
// Pin 3 und 4 auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~((1 << DDB3) | (1 << DDB4));
// Pin 0 und 3 wieder auf Ausgang und andere im ursprünglichen Zustand belassen:
DDRB |= (1 << DDB0) | (1 << DDB3);
// Alle Pins auf Eingang:
DDRB = 0x00;
</c>

== Vordefinierte Bitnummern für I/O-Register ==

Die Bitnummern (z. B. PCx, PINCx und DDCx für den Port C) sind in den io*.h-Dateien der avr-libc definiert und dienen lediglich der besseren Lesbarkeit. Man muss diese Definitionen nicht verwenden oder kann auch einfach "immer" PAx, PBx, PCx usw. nutzen, auch wenn der Zugriff auf Bits in DDRx- oder PINx-Registern erfolgt. Für den Compiler sind die Ausdrücke (1<<PC7), (1<<DDC7) und (1<<PINC7) identisch zu (1<<7) (genauer: der Präprozessor ersetzt die Ausdrücke (1<<PC7),... zu (1<<7)). Ein Ausschnitt der Definitionen für Port C eines ATmega32 aus der iom32.h-Datei zur Verdeutlichung (analog für die weiteren Ports):

<c>
...
/* PORTC */
#define PC7 7
#define PC6 6
#define PC5 5
#define PC4 4
#define PC3 3
#define PC2 2
#define PC1 1
#define PC0 0

/* DDRC */
#define DDC7 7
#define DDC6 6
#define DDC5 5
#define DDC4 4
#define DDC3 3
#define DDC2 2
#define DDC1 1
#define DDC0 0

/* PINC */
#define PINC7 7
#define PINC6 6
#define PINC5 5
#define PINC4 4
#define PINC3 3
#define PINC2 2
#define PINC1 1
#define PINC0 0
</c>

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen bzw. auszugeben.

== Ausgänge ==
Will man als Ausgang definierte Pins (entsprechende DDRx-Bits = 1) auf Logisch 1 setzen, setzt man die entsprechenden Bits im Portregister.

Mit dem Befehl
<c>
#include <avr/io.h>
...
PORTB = 0x04; /* besser PORTB=(1<<PB2) */

// übersichtliche Alternative - Binärschreibweise
PORTB = 0b00000100; /* direkte Zuweisung - übersichtlich */

</c>
wird also der Ausgang an Pin PB2 gesetzt (Beachte, dass die Bits immer ''von 0 an'' gezählt werden, das niederwertigste Bit ist also Bitnummer 0 und nicht etwa Bitnummer 1).

Man beachte, dass bei der Zuweisung mittels '''=''' immer alle Pins gleichzeitig angegeben werden. Man sollte also, wenn nur bestimmte Ausgänge geschaltet werden sollen, zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfließen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an Port B auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<c>
#include <avr/io.h>
...
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<PB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<PB2);

/* auch mehrere "gleichzeitig": */
PORTB |= (1<<PB4) | (1<<PB5); /* Pins PB4 und PB5 "high" */
</c>

"Ausschalten", also Ausgänge auf "low" setzen, erfolgt analog:

<c>
#include <avr/io.h>
...
PORTB &= ~(1<<PB2); /* löscht Bit 2 in PORTB und setzt damit Pin PB2 auf low */
PORTB &= ~( (1<<PB4) | (1<<PB5) ); /* Pin PB4 und Pin PB5 "low" */
</c>
Siehe auch [[Bitmanipulation]]

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind in aktuellen Versionen der avr-libc nicht mehr enthalten und auch nicht mehr erforderlich.

''Falls der Anfangszustand von Ausgängen kritisch ist, muss die Reihenfolge beachtet werden, mit der die Datenrichtung (DDRx) eingestellt und der Ausgabewert (PORTx) gesetzt wird:''

Für Ausgangspins, die mit Anfangswert "high" initialisiert werden sollen:
* zuerst die Bits im PORTx-Register setzen
* anschließend die Datenrichtung auf Ausgang stellen

Daraus ergibt sich die Abfolge für einen Pin, der bisher als Eingang mit abgeschaltetem Pull-Up konfiguriert war:
* setze PORTx: interner Pull-Up aktiv
* setze DDRx: Ausgang ("high")

Bei der Reihenfolge erst DDRx und dann PORTx kann es zu einem kurzen "low-Puls" kommen, der auch externe Pull-Up-Widerstände "überstimmt". Die (ungünstige) Abfolge: Eingang -> setze DDRx: Ausgang (auf "low", da PORTx nach Reset 0) -> setze PORTx: Ausgang auf high. Vergleiche dazu auch das Datenblatt Abschnitt ''Configuring the Pin''.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wir den Pegel über entsprechende Hardware (z. B. Optokoppler, [[Widerstand#Spannungsteiler|Spannungsteiler]], "Levelshifter" aka [[Pegelwandler]]) anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unseres Controllers eine logische 1 (Spannung größer ca. 0,7*Vcc) oder eine logische 0 (Spannung kleiner ca. 0,2*Vcc) anliegt. Detaillierte Informationen darüber, ab welcher Spannung ein Eingang als 0 ("low") bzw. 1 ("high") erkannt wird, liefert die Tabelle DC Characteristics im Datenblatt des genutzten Controllers.

{| class="wikitable" style="text-align:center"
|+ '''Spannungstabelle''' (ca. Grenzwerte)
|
! Low || High
|-
! bei 5 V
| 1 V || 3,5 V
|-
! bei 3,3 V
| 0,66 V || 2,31 V
|-
! bei 1,8 V
| 0,36 V || 1,26 V
|}

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.

{{Warnung|Dabei ist wichtig, zur Abfrage der Eingänge ''nicht'' etwa Portregister '''PORTx''' zu verwenden, sondern Eingangsregister '''PINx'''. Ansonsten liest man nicht den Zustand der Eingänge, sondern den Status der internen Pull-Up-Widerstände. Die Abfrage der Pinzustände über PORTx statt PINx ist ein häufiger Fehler beim AVR-"Erstkontakt".}}

Will man also die aktuellen Signalzustände von Port D abfragen und in eine Variable namens bPortD abspeichern, schreibt man folgende Befehlszeilen:

<c>
#include <avr/io.h>
#include <stdint.h>
...
uint8_t bPortD;
...
bPortD = PIND;
...
</c>

Mit den C-Bitoperationen kann man den Status der Bits abfragen.

<c>
#include <avr/io.h>
...
/* Fuehre Aktion aus, wenn Bit Nr. 1 (das "zweite" Bit) in PINC gesetzt (1) ist */
if ( PINC & (1<<PINC1) ) {
/* Aktion */
}

/* Fuehre Aktion aus, wenn Bit Nr. 2 (das "dritte" Bit) in PINB geloescht (0) ist */
if ( !(PINB & (1<<PINB2)) ) {
/* Aktion */
}
...
</c>
Siehe auch [[Bitmanipulation#Bits_prüfen]]

=== Interne Pull-Up Widerstände ===

Portpins für Ein- und Ausgänge (GPIO) eines AVR verfügen über zuschaltbare interne Pull-Up Widerstände (nominal mehrere 10kOhm, z. B. ATmega16 20-50kOhm). Diese können in vielen Fällen statt externer Widerstände genutzt werden.

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang''' geschaltet ist.

Wird der Wert des entsprechenden Portpins auf 1 gesetzt, so ist der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up Widerstand nicht aktiv. Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand verwenden, aber nicht beide zusammen.

Im Beispiel werden alle Pins des Ports D als Eingänge geschaltet und alle Pull-Up Widerstände aktiviert. Weiterhin wird Pin PC7 als Eingang geschaltet und dessen interner Pull-Up Widerstand aktiviert, ohne die Einstellungen für die anderen Portpins (PC0-PC6) zu verändern.

<c>
#include <avr/io.h>
...
DDRD = 0x00; /* alle Pins von Port D als Eingang */
PORTD = 0xff; /* interne Pull-Ups an allen Port-Pins aktivieren */
...
DDRC &= ~(1<<PC7); /* Pin PC7 als Eingang */
PORTC |= (1<<PC7); /* internen Pull-Up an PC7 aktivieren */
</c>

=== Taster und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller, ist zwischen zwei unterschiedliche Methoden zu unterscheiden: ''Active Low'' und ''Active High''.

<gallery widths="300" heights="300" caption="Anschluss mechanischer Kontakte an einen µC">
Image:Active Low.gif|'''Active Low:''' Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet. Damit bei offenem Schalter der Controller kein undefiniertes Signal bekommt, wird zwischen die Versorgungsspannung und den Eingangspin ein sogenannter '''Pull-Up''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffnetem Schalter auf logisch 1 zu ziehen.
Image:Active High.gif|'''Active High:''' Hier wird der Kontakt zwischen die Versorgungsspannung und den Eingangspin geschaltet. Damit bei offener Schalterstellung kein undefiniertes Signal am Controller ansteht, wird zwischen den Eingangspin und die Masse ein '''Pull-Down''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter Schalterstellung auf logisch 0 zu halten.
</gallery>

Der Widerstandswert von Pull-Up- und Pull-Down-Widerständen ist an sich nicht kritisch. Wird er allerdings zu hoch gewählt, ist die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10 kOhm eingebürgert. Die AVRs verfügen an den meisten Pins über zuschaltbare interne Pull-Up Widerstände (vgl. Abschnitt [[AVR-GCC-Tutorial#Interne Pull-Up Widerstände|Interne Pull-Up Widerstände]]), welche insbesondere wie hier bei Tastern und ähnlichen Bauteilen (z. B. Drehgebern) statt externer Bauteile verwendet werden können. Interne Pull-Down-Widerstand sind nicht verfügbar und müssen daher in Form zusätzlicher Bauteile in die Schaltung eingefügt werden.

==== Taster entprellen ====

Siehe: ''[[Entprellung#Warteschleifen-Verfahren|Entprellung: Warteschleifen-Verfahren]]

= Warteschleifen (delay.h) =

Der Programmablauf kann verschiedene Arten von Wartefunktionen erfordern:

* Warten im Sinn von Zeitvertrödeln
* Warten auf einen bestimmten Zustand an den I/O-Pins
* Warten auf einen bestimmten Zeitpunkt (siehe Timer)
* Warten auf einen bestimmten Zählerstand (siehe Counter)

Der einfachste Fall, das Zeitvertrödeln, kann in vielen Fällen und mit großer Genauigkeit anhand der avr-libc Bibliotheksfunktionen _delay_ms() und _delay_us() erledigt werden. Die Bibliotheksfunktionen sind einfachen Zählschleifen (Warteschleifen) vorzuziehen, da leere Zählschleifen ohne besondere Vorkehrungen sonst bei eingeschalteter Optimierung vom avr-gcc-Compiler wegoptimiert werden. Weiterhin sind die Bibliotheksfunktionen bereits darauf vorbereitet, die in F_CPU definierte Taktfrequenz zu verwenden. Außerdem sind die Funktionen der Bibliothek wirklich getestet.

Einfach!? Schon, aber während gewartet wird, macht der µC nichts anderes mehr (abgesehen von möglicherweise auftretenden Interrupts, falls welche aktiviert sind). Die Wartefunktion blockiert den Programmablauf. Möchte man einerseits warten, um z. B. eine LED blinken zu lassen und gleichzeitig andere Aktionen ausführen z. B. weitere LED bedienen, sollten die Timer/Counter des AVR verwendet werden.

Die Bibliotheksfunktionen funktionieren allerdings nur dann korrekt, wenn sie mit zur Übersetzungszeit (beim Compilieren) bekannten konstanten Werten aufgerufen werden. Der Quellcode muss mit eingeschalteter Optimierung übersetzt werden, sonst wird sehr viel Maschinencode erzeugt, und die Wartezeiten stimmen nicht mehr mit dem Parameter überein.

Eine weitere Einschränkung liegt darin, daß sie möglicherweise länger warten, als erwartet, nämlich in dem Fall, daß Interrupts auftreten und die _delay...()-Funktion unterbrechen. Genau genommen warten diese nämlich nicht eine bestimmte Zeit, sondern verbrauchen eine bestimmte Anzahl von Prozessortakten. Die wiederum ist so bemessen, daß ohne Unterbrechung durch Interrupts die gewünschte Wartezeit erreicht wird.
Wird das Warten aber durch eine oder mehrere ISR unterbrochen, die zusammen 1% Prozessorzeit verbrauchen, dann dauert das Warten etwa 1% länger. Bei 50% Last durch die ISR dauert das Warten doppelt solange wie gewünscht, bei 90% zehnmal solange...

Abhängig von der Version der Bibliothek verhalten sich die Bibliotheksfunktionen etwas unterschiedlich.

== avr-libc Versionen bis 1.6 ==

Die Wartezeit der Funktion _delay_ms() ist auf 262,14ms/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 13,1ms warten. Die Wartezeit der Funktion _delay_us() ist auf 768us/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 38,4µs warten. Längere Wartezeiten müssen dann über einen mehrfachen Aufruf in einer Schleife gelöst werden.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z. B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h> /* in älteren avr-libc Versionen <avr/delay.h> */

/*
lange, variable Verzögerungszeit, Einheit in Millisekunden

Die maximale Zeit pro Funktionsaufruf ist begrenzt auf
262.14 ms / F_CPU in MHz (im Beispiel:
262.1 / 3.6864 = max. 71 ms)

Daher wird die kleine Warteschleife mehrfach aufgerufen,
um auf eine längere Wartezeit zu kommen. Die zusätzliche
Prüfung der Schleifenbedingung lässt die Wartezeit geringfügig
ungenau werden (macht hier vielleicht 2-3ms aus).
*/

void long_delay(uint16_t ms)
{
for(; ms>0; ms--) _delay_ms(1);
}

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) // Endlosschleife
{
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z. B. angeschlossene LED
long_delay(1000); // Eine Sekunde warten...
}

return 0;
}
</c>

== avr-libc Versionen ab 1.7 ==

_delay_ms() kann mit einem Argument bis 6553,5 ms (= 6,5535 Sekunden) benutzt werden. Es ist nicht möglich, eine Variable als Argument zu übergeben. Wird die früher gültige Grenze von 262,14 ms/F_CPU (in MHz) überschritten, so arbeitet _delay_ms() einfach etwas ungenauer und zählt nur noch mit einer Auflösung von 1/10 ms. Eine Verzögerung von 1000,10 ms ließe sich nicht mehr von einer von 1000,19 ms unterscheiden. Ein Verlust, der sich im Allgemeinen verschmerzen lässt. Dem Programmierer wird keine Rückmeldung gegeben, dass die Funktion ggf. gröber arbeitet, d.h. wenn es darauf ankommt, bitte den Parameter wie bisher geschickt wählen.

Die Funktion _delay_us() wurde ebenfalls erweitert. Wenn deren maximal als genau behandelbares Argument überschritten wird, benutzt diese intern _delay_ms(). Damit gelten in diesem Fall die _delay_ms() Einschränkungen.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus, avr-libc ab Version 1.6
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z.B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h>

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z.B. angeschlossene LED
_delay_ms(1000); // Eine Sekunde +/-1/10000 Sekunde warten...
// funktioniert nicht mit Bibliotheken vor 1.6

}
return 0;
}
</c>

Trick zur Übergabe einer Variablen an _delay_ms():
<c>
#include <avr/io.h>
#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h>

void sleep ( uint8_t ms )
{
for(; ms > 0; ms--) _delay_ms(1);
}

int main( void )
{
int x = 0; // Variable als Wartezeit erstellen
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z.B. angeschlossene LED
sleep(x);
x++;
}
return 0;
}
</c>

Die _delay_ms() und die _delay_us aus '''avr-libc 1.7.0''' sind fehlerhaft. _delay_ms () läuft 4x schneller als erwartet. Abhilfe ist eine korrigierte Includedatei: [http://www.mikrocontroller.net/topic/196738#1943039]

= Programmieren mit Interrupts =

<div style="float:right; margin:2em;">
[[Image:Interrupt Programme.gif]]
</div>
Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Tritt ein Interrupt auf, unterbricht (engl. interrupts) der Controller die Verarbeitung des Hauptprogramms und verzweigt zu einer Interruptroutine. Das Hauptprogramm wird also beim Eintreffen eines Interrupts unterbrochen, die Interruptroutine ausgeführt und danach erst wieder das Hauptprogramm an der Unterbrechungsstelle fortgesetzt (vgl. die Abbildung).

Um Interrupts verarbeiten zu können, ist folgendes zu beachten:

* Für jede aktivierte Interruptquelle ist eine Funktion zu programmieren, in der die beim Auftreten des jeweiligen Interrupts erforderlichen Verarbeitungsschritte enthalten sind. Für diese Funktion existieren verschiedene Bezeichnungen. Üblich sind die englischen Begriffe Interrupt-Handler oder Interrupt-Service-Routinen (ISR), man findet aber auch die Bezeichnungen Interruptverarbeitungs- oder -behandlungsroutine oder auch kurz Interuptroutine. Zum Beispiel wird üblicherweise in der ISR zur Verarbeitung des Empfangsinterrupts eines UARTs (UART-RX Interrupt) das empfangene Zeichen in einen Zwischenspeicher (FIFO-Buffer) kopiert, dessen Inhalt später von anderen Programmteilen geleert wird. Sofern der Zwischenspeicher ausreichend groß ist, geht also kein Zeichen verloren, auch wenn im Hauptprogramm zeitintensive Operationen durchgeführt werden.
* Die benötigten Interrupts sind in den jeweiligen Funktionsbausteinen einzuschalten. Dies erfolgt über das jeweilige Aktivierungsbit (Interrupt Enable) in einem der Hardwareregister (z.B. RX(Complete)Interrupt Enable eines UARTs)
* Sämtliche Interrupts werden über einen weiteren globalen Schalter aktiviert und deaktiviert. Zur Verarbeitung der Interrupts ist dieser Schalter zu aktivieren (sei(), siehe unten).

Alle Punkte sind zu beachten. Fehlt z.B. die globale Aktivierung, werden Interruptroutinen auch dann nicht aufgerufen, wenn sie im Funktionsbaustein eingeschaltet sind und eine Behandlungsroutine verhanden ist.

Siehe auch

* [http://www.mikrocontroller.net/forum/read-1-235092.html#new Ausführlicher Thread im Forum]
* Artikel [[Interrupt]]
* Artikel [[Multitasking]]
{{Clear}}

== Anforderungen an Interrupt-Routinen ==

Um unliebsamen Überraschungen vorzubeugen, sollten einige Grundregeln bei der Implementierung der Interruptroutinen beachtet werden. Interruptroutinen sollten möglichst kurz und schnell abarbeitbar sein, daraus folgt:

* Keine umfangreichen Berechnungen innerhalb der Interruptroutine. (*)
* Keine langen Programmschleifen.
* Obwohl es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen, wird davon ohne genaue Kenntnis der internen Abläufe dringend abgeraten.

Interruptroutinen (ISRs) sollten also möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

(*)
Hinweis:
Es gibt allerdings die seltene Situation, dass man gerade eingelesene
ADC-Werte sofort verarbeiten muss. Besonders dann, wenn man mehrere Werte sehr
schnell hintereinander bekommt. Dann bleibt einem nichts anderes übrig, als die
Werte noch in der ISR zu verarbeiten. Kommt aber sehr selten vor und sollte
durch geeignete Wahl des Systemtaktes bzw. Auswahl des Controllers vermieden werden!

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf einem AVR AT90S2313 auslösen, wobei die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

Die Anzahl der möglichen Interruptquellen variiert zwischen den verschiedenen Microcontroller-Typen. Im Zweifel hilft ein Blick ins Datenblatt ("Interrupt Vectors").

== Register ==

Der AT90S2313 verfügt über 2 Register die mit den
Interrupts zusammen hängen.

{| class="wikitable"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''a'''sk''' Register. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6|| 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INT1''' || '''INT0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INTF1''' || '''INTF0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Bedingung, entsprechend der Konfiguration, als eingetreten erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Bedingung, entsprechend der Konfiguration, als eingetreten erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine MCU-Funktionen.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''-'''|| '''-'''|| '''SE'''|| '''SM'''|| '''ISC11'''|| '''ISC10'''|| '''ISC01'''|| '''ISC00'''
|-
! R/W
| R || R || R/W || R/W || R/W || R/W || R/W || R/W
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0

|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt über den Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC11 || ISC10 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}

'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC01 || ISC00 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}

|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem Zeitpunkt bereits wieder das GIE-bit zu setzen, wird dringend davon abgeraten. Dieses wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe, weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.



== Interrupts mit dem AVR GCC Compiler (WinAVR) ==



Funktionen zur Interrupt-Verarbeitung werden in den Includedateien ''interrupt.h'' der avr-libc zur Verfügung gestellt (bei älterem Quellcode zusätzlich ''signal.h'').

<c>
// fuer sei(), cli() und ISR():
#include <avr/interrupt.h>
</c>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status Register gesetzt.

<c>
sei();
</c>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird gelöscht.

<c>
cli();
</c>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf. Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen. Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen Zustands die Interrupts aktivieren, was zu unerwünschten Seiteneffekten führen kann. Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

//...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O" nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern. Dazu ist eine "timed sequence"
einzuhalten (vgl Datenblatt ATmega16, Stand 10/04, S. 229):
Das JTD-Bit muss zweimal innerhalb von 4 Taktzyklen geschrieben
werden. Ein Interrupt zwischen den beiden Schreibzugriffen wuerde
die erforderliche Sequenz "brechen", das JTAG-Interface bliebe
weiterhin aktiv und die IO-Pins weiterhin für JTAG reserviert. */

MCUCSR |= (1<<JTD);
MCUCSR |= (1<<JTD); // 2 mal in Folge ,vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
//...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
//...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichtSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
//...

}
</c>


Zu den aktivierten Interrupts ist eine Funktion zu programmieren, deren Code aufgerufen wird, wenn der betreffende Interrupt auftritt (Interrupt-Handler, Interrupt-Service-Routine). Dazu existiert die Definition (ein Makro) '''ISR'''.

=== ISR ===

(''ISR()'' ersetzt bei neueren Versionen der avr-libc ''SIGNAL()''. SIGNAL sollte nicht mehr genutzt werden, zur Portierung von SIGNAL nach ISR siehe den [[AVR-GCC-Tutorial#Anhang|Anhang]].)

<c>
#include <avr/interrupt.h>
//...
ISR(Vectorname) /* vormals: SIGNAL(siglabel) dabei Vectorname != siglabel ! */
{
/* Interrupt Code */
}
</c>

Mit ''ISR'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektors angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Die Bezeichnung entspricht dem Namen aus dem Datenblatt, bei dem die Leerzeichen durch Unterstriche ersetzt sind und ein ''_vect'' angehängt ist.

Als Beispiel ein Ausschnitt aus der Datei für den ATmega8 (bei WinAVR Standardinstallation in C:\WinAVR\avr\include\avr\iom8.h) in der neben den aktuellen Namen für ''ISR'' (*_vect) noch die Bezeichnungen für das inzwischen nicht mehr aktuelle ''SIGNAL'' (SIG_*) enthalten sind.

<c>
//...
/* $Id: iom8.h,v 1.13 2005/10/30 22:11:23 joerg_wunsch Exp $ */

/* avr/iom8.h - definitions for ATmega8 */
//...

/* Interrupt vectors */

/* External Interrupt Request 0 */
#define INT0_vect _VECTOR(1)
#define SIG_INTERRUPT0 _VECTOR(1)

/* External Interrupt Request 1 */
#define INT1_vect _VECTOR(2)
#define SIG_INTERRUPT1 _VECTOR(2)

/* Timer/Counter2 Compare Match */
#define TIMER2_COMP_vect _VECTOR(3)
#define SIG_OUTPUT_COMPARE2 _VECTOR(3)

/* Timer/Counter2 Overflow */
#define TIMER2_OVF_vect _VECTOR(4)
#define SIG_OVERFLOW2 _VECTOR(4)

/* Timer/Counter1 Capture Event */
#define TIMER1_CAPT_vect _VECTOR(5)
#define SIG_INPUT_CAPTURE1 _VECTOR(5)

/* Timer/Counter1 Compare Match A */
#define TIMER1_COMPA_vect _VECTOR(6)
#define SIG_OUTPUT_COMPARE1A _VECTOR(6)

/* Timer/Counter1 Compare Match B */
#define TIMER1_COMPB_vect _VECTOR(7)
#define SIG_OUTPUT_COMPARE1B _VECTOR(7)

//...
</c>


Mögliche Funktionsrümpfe für Interruptfunktionen sind zum Beispiel:

<c>
#include <avr/interrupt.h>
/* veraltet: #include <avr/signal.h> */

ISR(INT0_vect) /* veraltet: SIGNAL(SIG_INTERRUPT0) */
{
/* Interrupt Code */
}

ISR(TIMER0_OVF_vect) /* veraltet: SIGNAL(SIG_OVERFLOW0) */
{
/* Interrupt Code */
}

ISR(USART_RXC_vect) /* veraltet: SIGNAL(SIG_UART_RECV) */
{
/* Interrupt Code */
}

// und so weiter und so fort...
</c>

Auf die korrekte Schreibweise der Vektorbezeichnung ist zu achten. Der gcc-Compiler prüft erst ab Version 4.x, ob ein Signal/Interrupt der angegebenen Bezeichnung tatsächlich in der Includedatei definiert ist und gibt andernfalls eine Warnung aus. Bei WinAVR (ab 2/2005) wurde die Überprüfung auch in den mitgelieferten Compiler der Version 3.x integriert. Aus dem gcc-Quellcode Version 3.x selbst erstellte Compiler enthalten die Prüfung nicht (vgl. [[AVR-GCC]]).

Während der Ausführung der Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== Unterbrechbare Interruptroutinen ===

"Faustregel": im Zweifel '''ISR'''. Die nachfolgend beschriebene Methode nur dann verwenden, wenn man sich über die unterschiedliche Funktionsweise im Klaren ist.

<c>
#include <avr/interrupt.h>

ISR(XXX,ISR_NOBLOCK) /* veraltet: INTERRUPT(SIG_OVERFLOW0) */
{
/* Interrupt-Code */
}
</c>

Hierbei steht XXX für den oben beschriebenen Namen des Vektors (also z. B. ''TIMER0_OVF_vect''). Der Unterschied im Vergleich zu einer herkömmlichen ISR ist, dass hier beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit durch Einfügen einer SEI-Anweisung direkt wieder gesetzt und somit alle Interrupts zugelassen werden – auch XXX-Interrupts.

Bei unsachgemässer Handhabung kann dies zu erheblichen Problemen durch Rekursion wie einem Stack-Overflow oder anderen unerwarteten Effekten führen und sollte wirklich nur dann eingesetzt werden, wenn man sich sicher ist, das Ganze auch im Griff zu haben.

Insbesondere sollte möglichst am ISR-Anfang die auslösende IRQ-Quelle deaktiviert und erst am Ende der ISR wieder aktiviert werden. Robuster als die Verwendung einer NOBLOCK-ISR ist daher folgender ISR-Aufbau:

<c>
#include <avr/interrupt.h>

ISR (XXX)
{
// Implementiere die ISR ohne zunaechst weitere IRQs zuzulassen

<<Dektiviere die XXX-IRQ>>

// Erlaube alle Interrupts (ausser XXX)
sei();

//... Code ...

// IRQs global deaktivieren um die XXX-IRQ wieder gefahrlos
// aktivieren zu koennen
cli();

<<Aktiviere die XXX-IRQ>>
}
</c>
Auf diese Weise kann sich die XXX-IRQ nicht selbst unterbrechen, was zu einer Art Endlosschleife führen würde.

Siehe auch: Hinweise in [[AVR-GCC]]

siehe dazu: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

== Datenaustausch mit Interrupt-Routinen ==

Variablen, die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)) als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte der Compiler den Code so optimieren, dass der Wert der Variablen nur in Prozessorregistern zwischengespeichert wird, die nichts von der Änderung woanders mitbekommen.

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
//...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z. B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt ISR, wird z.B. alle 10ms ausgefuehrt
ISR(TIMER1_COMPA_vect)
{
// hier wird gKeyCounter veraendert. Die übrigen
// Programmteile müssen diese Aenderung "sehen":
// volatile -> aktuellen Wert immer in den Speicher schreiben
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
}
else {
gKeyCounter = 0;
}
}

//...

int main(void)
{
//...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
//...
// hier wird auf gKeyCounter zugegriffen. Dazu muss der in der
// ISR geschriebene Wert bekannt sein:
// volatile -> aktuellen Wert immer aus dem Speicher lesen
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt" */
}
else {
/* hier: Code fuer "Taste kurz gedrueckt" */
}
}
//...
}
</c>

Wird innerhalb einer ISR mehrfach auf eine mit volatile deklarierte Variable zugegriffen, wirkt sich dies ungünstig auf die Verarbeitungsgeschwindigkeit aus, da bei jedem Zugriff mit dem Speicherinhalt abgeglichen wird. Da bei AVR-Controllern ''innerhalb'' einer ISR keine Unterbrechungen zu erwarten sind, bietet es sich an, einen Zwischenspeicher in Form einer lokalen Variable zu verwenden, deren Inhalt zu Beginn und am Ende mit dem der volatile Variable synchronisiert wird. Lokale Variable werden bei eingeschalteter Optimierung mit hoher Wahrscheinlichkeit in Prozessorregistern verwaltet und der Zugriff darauf ist daher nur mit wenigen internen Operationen verbunden. Die ISR aus dem vorherigen Beispiel lässt sich so optimieren:

<c>
//...
ISR(TIMER1_COMPA_vect)
{
uint8_t tmp_kc;

tmp_kc = gKeyCounter; // Uebernahme in lokale Arbeitsvariable

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (tmp_kc < CNTREPEAT) {
tmp_kc++;
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc; // Zurueckschreiben
}
//...
</c>

Zum Vergleich die Disassemblies (Ausschnitte der "lss-Dateien", compiliert für ATmega162) im Anschluss. Man erkennt den viermaligen Zugriff auf die Speicheraddresse von ''gKeyCounter'' (hier 0x032A) in der ISR ohne "Cache"-Variable und den zweimaligen Zugriff in der Variante mit Zwischenspeicher. Im Beispiel ist der Vorteil gering, bei komplexeren Routinen kann die Zwischenspeicherung in lokalen Variablen jedoch zu deutlicheren Verbesserungen führen.

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
876: ca 99 sbic 0x19, 2 ; 25
878: 0a c0 rjmp .+20 ; 0x88e <__vector_13+0x24>
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
87a: 80 91 2a 03 lds r24, 0x032A
87e: 88 3c cpi r24, 0xC8 ; 200
880: 40 f4 brcc .+16 ; 0x892 <__vector_13+0x28>
882: 80 91 2a 03 lds r24, 0x032A
886: 8f 5f subi r24, 0xFF ; 255
888: 80 93 2a 03 sts 0x032A, r24
88c: 02 c0 rjmp .+4 ; 0x892 <__vector_13+0x28>
}
else {
gKeyCounter = 0;
88e: 10 92 2a 03 sts 0x032A, r1
892: 8f 91 pop r24
894: 0f 90 pop r0
896: 0f be out 0x3f, r0 ; 63
898: 0f 90 pop r0
89a: 1f 90 pop r1
89c: 18 95 reti
</pre>

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
uint8_t tmp_kc;

tmp_kc = gKeyCounter;
876: 80 91 2a 03 lds r24, 0x032A

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
87a: ca 9b sbis 0x19, 2 ; 25
87c: 02 c0 rjmp .+4 ; 0x882 <__vector_13+0x18>
87e: 80 e0 ldi r24, 0x00 ; 0
880: 03 c0 rjmp .+6 ; 0x888 <__vector_13+0x1e>
if (tmp_kc < CNTREPEAT) {
882: 88 3c cpi r24, 0xC8 ; 200
884: 08 f4 brcc .+2 ; 0x888 <__vector_13+0x1e>
tmp_kc++;
886: 8f 5f subi r24, 0xFF ; 255
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc;
888: 80 93 2a 03 sts 0x032A, r24
88c: 8f 91 pop r24
88e: 0f 90 pop r0
890: 0f be out 0x3f, r0 ; 63
892: 0f 90 pop r0
894: 1f 90 pop r1
896: 18 95 reti
</pre>

=== volatile und Pointer ===

Bei '''volatile''' in Verbindung mit Pointern ist zu beachten, ob der Pointer selbst oder die Variable, auf die der Pointer zeigt, '''volatile''' ist.

<c>
volatile uint8_t *a; // das Ziel von a ist volatile

uint8_t *volatile a; // a selbst ist volatile
</c>

Falls der Pointer volatile ist (zweiter Fall im Beispiel), ist zu beachten, dass der Wert des Pointers, also eine Speicheradresse, intern in mehr als einem Byte verwaltet wird. Lese- und Schreibzugriffe im Hauptprogramm (außerhalb von Interrupt-Routinen) sind daher so zu implementieren, dass alle Teilbytes der Adresse konsistent bleiben, vgl. dazu den folgenden Abschnitt.

=== Variablen größer 1 Byte ===

Bei Variablen größer ein Byte, auf die in Interrupt-Routinen und im Hauptprogramm zugegriffen wird, muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes außerhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<c>
//...
volatile uint16_t gMyCounter16bit;
//...
ISR(...)
{
//...
gMyCounter16Bit++;
//...
}

int main(void)
{
uint16_t tmpCnt;
//...
// nicht gut: Mglw. hier ein Fehler, wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor dem Kopieren des zweiten Bytes
// ein Interrupt auftritt, der den Inhalt von MyCounter verändert.
tmpCnt = gMyCounter16bit;

// besser: Änderungen "außerhalb" verhindern -> alle "Teilbytes"
// bleiben konsistent
cli(); // Interrupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren

// oder: vorheriger Status des globalen Interrupt-Flags bleibt erhalten
uint8_t sreg_tmp;
sreg_tmp = SREG; /* Sichern */
cli()
tmpCnt = gMyCounter16Bit;
SREG = sreg_tmp; /* Wiederherstellen */

// oder: mehrfach lesen, bis man konsistente Daten hat
uint16_t count1 = gMyCounter16Bit;
uint16_t count2 = gMyCounter16Bit;
while (count1 != count2) {
count1 = count2;
count2 = gMyCounter16Bit;
}
tmpCnt = count1;
//...
}
</c>

Die avr-libc bietet ab Version 1.6.0(?) einige Hilfsfunktionen/Makros, mit der im Beispiel oben gezeigten Funktionalität, die zusätzlich auch sogenannte [http://en.wikipedia.org/wiki/Memory_barrier memory barriers] beinhalten. Diese stehen nach #include <util/atomic.h> zur Verfügung.
<c>
//...
#include <util/atomic.h>
//...

// analog zu cli, Zugriff, sei:
ATOMIC_BLOCK(ATOMIC_FORCEON) {
tmpCnt = gMyCounter16Bit;
}

// oder:

// analog zu Sicherung des SREG, cli, Zugriff und Zurückschreiben des SREG:
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
tmpCnt = gMyCounter16Bit;
}

//...
</c>

* siehe auch [http://www.nongnu.org/avr-libc/user-manual/group__util__atomic.html Dokumentation der avr-libc zu atomic.h]

== Interrupt-Routinen und Registerzugriffe ==

Falls Register sowohl im Hauptprogramm als auch in Interrupt-Routinen verändert werden, ist darauf zu achten, dass diese Zugriffe sich nicht überlappen. Nur wenige Anweisungen lassen sich in sogenannte "atomare" Zugriffe übersetzen, die nicht von Interrupt-Routinen unterbrochen werden können.

Zur Veranschaulichung eine Anweisung, bei der ein Bit und im Anschluss drei Bits in einem Register gesetzt werden:

<c>
#include <avr/io.h>

int main(void)
{
//...
PORTA |= (1<<PA0);

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
//...
}
</c>

Der Compiler übersetzt diese Anweisungen für einen ATmega128 bei Optimierungsstufe "S" nach:

<div class="code"><pre>
...
PORTA |= (1<<PA0);
d2: d8 9a sbi 0x1b, 0 ; 27 (a)

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
d4: 8b b3 in r24, 0x1b ; 27 (b)
d6: 8c 61 ori r24, 0x1C ; 28 (c)
d8: 8b bb out 0x1b, r24 ; 27 (d)
...
</pre></div>

Das Setzen des einzelnen Bits wird bei eingeschalteter Optimierung für Register im unteren Speicherbereich in eine einzige Assembler-Anweisung (sbi) übersetzt und ist nicht anfällig für Unterbrechungen durch Interrupts. Die Anweisung zum Setzen von drei Bits wird jedoch in drei abhängige Assembler-Anweisungen übersetzt und bietet damit zwei "Angriffspunkte" für Unterbrechungen. Eine Interrupt-Routine könnte nach dem Laden des Ausgangszustands in den Zwischenspeicher (hier Register 24) den Wert des Registers ändern, z. B. ein Bit löschen. Damit würde der Zwischenspeicher nicht mehr mit dem tatsächlichen Zustand übereinstimmen aber dennoch nach der Bitoperation (hier ori) in das Register zurückgeschrieben.

Beispiel: PORTA sei anfangs 0b00000000. Die erste Anweisung (a) setzt Bit 0 auf '''1''', PORTA ist danach 0b0000000'''1'''. Nun wird im ersten Teil der zweiten Anweisung der Portzustand in ein Register eingelesen (b). Unmittelbar darauf (vor (c)) "feuert" ein Interrupt, in dessen Interrupt-Routine Bit 0 von PORTA gelöscht wird. Nach Verlassen der Interrupt-Routine hat PORTA den Wert 0b00000000. In den beiden noch folgenden Anweisungen des Hauptprogramms wird nun der zwischengespeicherte "alte" Zustand 0b00000001 mit 0b00011100 logisch-'''ODER'''-verknüft (c) und das Ergebnis 0b00011101 in PortA geschrieben (d). Obwohl zwischenzeitlich Bit 0 gelöscht wurde, ist es nach (d) wieder gesetzt.

Lösungsmöglichkeiten:
* Register ohne besondere Vorkehrungen nicht in Interruptroutinen ''und'' im Hauptprogramm verändern.
* Interrupts vor Veränderungen in Registern, die auch in ISRs verändert werden, deaktivieren ("cli").
* Bits einzeln löschen oder setzen. sbi und cbi können nicht unterbrochen werden. Vorsicht: nur Register im unteren Speicherbereich sind mittels sbi/cbi ansprechbar. Der Compiler kann nur für diese sbi/cbi-Anweisungen generieren. Für Register außerhalb dieses Adressbereichs ("Memory-Mapped"-Register) werden auch zur Manipulation einzelner Bits abhängige Anweisungen erzeugt (lds,...,sts).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8. (Stand: avr-libc Vers. 1.0.4)

== Interruptflags löschen ==

Beim Löschen von Interruptflags haben AVRs eine Besonderheit, die auch im Datenblatt beschrieben ist: Es wird zum Löschen eine 1 in das betreffende Bit geschrieben.

Hinweis: Dazu '''nicht''' übliche bitweise VerODERung nehmen, sondern eine direkte Zuweisung machen ([http://www.mikrocontroller.net/topic/171148#1640133 Erklärung]).

== Was macht das Hauptprogramm? ==

Im einfachsten (Ausnahme-)Fall gar nichts mehr. Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der main-Funktion lediglich noch die Interrupts aktiviert und dann in einer Endlosschleife verharrt. Sämtliche Funktionen werden dann in den ISRs abgearbeitet. Diese Vorgehensweise ist jedoch bei den meisten Anwendungen schlecht: man verschenkt eine Verarbeitungsebene und hat außerdem möglicherweise Probleme durch Interruptroutinen, die zu viel Verarbeitungszeit benötigen.

Normalerweise wird man in den Interruptroutinen nur die bei Auftreten des jeweiligen Interruptereignisses unbedingt notwendigen Operationen ausführen lassen. Alle weniger kritischen Aufgaben werden dann im Hauptprogramm abgearbeitet.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sogenannten [[Sleep Mode |''Sleep-Modes'']] ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comparators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrupts den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen (eigentlich Makros) der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

;set_sleep_mode (uint8_t mode): Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z. B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
;sleep_enable(): Aktiviert den gesetzten Schlafmodus, versetzt den Controller aber noch nicht in den Schlafmodus
;sleep_cpu(): Versetzt den Controller in den Schlafmodus .sleep_cpu wird im Prinzip durch die Assembler-Anweisung ''sleep'' ersetzt.
;sleep_disable(): Deaktiviert den gesetzten Schlafmodus
;sleep_mode(): Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus. Das Makro entspricht sleep_enable()+sleep_cpu()+sleep_disable(), beinhaltet also nicht die Aktivierung von Interrupts (besser nicht benutzen).

Bei Anwendung von sleep_cpu() müssen Interrupts also bereits freigeben sein (sei()), da der Controller sonst nicht mehr "aufwachen" kann. sleep_mode() ist nicht geeignet für die Verwendung in ISR Interrupt-Service-Routinen, da bei deren Abarbeitung Interrupts global deaktiviert sind und somit auch die möglichen "Aufwachinterrupts". Abhilfe: stattdessen sleep_enable(), sei(), sleep_cpu(), sleep_disable() und evtl. cli() verwenden (vgl. Dokumentation der avr-libc).

<c>
#include <avr/io.h>
#include <avr/sleep.h>

int main(void)
{
...

while (1) {
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach Auftreten eines entsprechenden
// "Aufwach-Interrupts" verarbeitet
...
}
}
</c>

In älteren Versionenen der avr-libc wurden nicht alle AVR-Controller durch die sleep-Funktionen richtig angesteuert. Mit avr-libc 1.2.0 wurde die Anzahl der unterstützten Typen jedoch deutlich erweitert. Bei nicht-unterstützten Typen erreicht man die gewünschte Funktionalität durch direkte "[[Bitmanipulation]]" der entsprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler oder sleep_cpu():

<c>
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 "manuell" aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep"::); // alternativ sleep_cpu() aus sleep.h
...
</c>

== Sleep Modi ==
Zu beachten ist, dass unterschiedliche Prozessoren aus der AVR Familie unterschiedliche Sleep-Modi unterstützen oder nicht unterstützen. Auskunft über die tatsächlichen Gegebenheiten gibt, wie immer, das zum Prozessor gehörende Datenblatt. Die unterschiedlichen Modi unterscheiden sich dadurch, welche Bereiche des Prozessors abgeschaltet werden. Damit korrespondiert unmittelbar welche Möglichkeiten es gibt, den Prozessor aus den jeweiligen Sleep Modus wieder aufzuwecken.

;Idle Mode (SLEEP_MODE_IDLE): Die CPU kann durch SPI, USART, Analog Comperator, ADC, TWI, Timer, Watchdog und irgendeinen anderen Interrupt wieder aufgeweckt werden.

;ADC Noise Reduction Mode (SLEEP_MODE_ADC): In diesem Modus liegt das Hauptaugenmerk darauf, die CPU soweit stillzulegen, dass der ADC möglichst keine Störungen aus dem inneren der CPU auffangen kann. Aufwachen aus diesem Modus kann ausgelöst werden durch den ADC, externe Interrupts, TWI, Timer und Watchdog.

;Power-Down Mode (SLEEP_MODE_PWR_DOWN): In diesem Modus wird ein externer Oszillator (Quarz, Quarzoszillator) gestoppt. Geweckt werden kann die CPU durch einen externen Level Interrupt, TWI, Watchdog, Brown-Out-Reset

;Power-Save-Mode (SLEEP_MODE_PWR_SAVE): Power-Save ist identisch zu Power-Down mit einer Ausnahme: Ist der Timer 2 auf die Verwendung eines externen Taktes konfiguriert, so läuft dieser Timer auch im Power-Save weiter und kann die CPU mit einem Interrupt aufwecken.

;Standby-Mode (SLEEP_MODE_STANDBY, SLEEP_MODE_EXT_STANDBY): Voraussetzung für den Standby-Modus ist die Verwendung eines Quarzes oder eines Quarzoszillators (also einer externen Taktquelle). Ansonsten ist dieser Modus identisch zum Power-Down Modus. Vorteil dieses Modus ist eine kürzere Aufwachzeit.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes
* [http://www.mikrocontroller.net/topic/96369#832712 Forenbeitrag] zur "Nichtverwendung" von sleep_mode in ISRs.

= Zeiger =
Zeiger (engl. ''Pointer'') sind Variablen, die die Adresse von Daten oder Funktionen enthalten und belegen 16 Bits. Die Größe hängt mit dem adressierbaren Speicherbereich zusammen und der GCC reserviert dann den entsprechenden Platz.
Ggf. ist es also günstiger, Indizes auf Arrays (Listen) zu verwenden, so dass der GCC für die Zeigerarithmetik den erforderlichen RAM nur temporär benötigt.

Siehe auch: [[Zeiger]]

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (genauer statisches RAM/SRAM) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als FLASH-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z. B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin selten sinnvoll ist und auch nur bei einigen RAM-losen Typen nach [http://lightner.net/avr/ATtinyAvrGcc.html "Bastelarbeiten"] möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein. Für die Typen ATtiny2313, ATtiny26 und viele weitere der "ATtiny-Reihe" gelten die Ausführungen ebenfalls.

Siehe auch:
* [[Binäre Daten zum Programm hinzufügen]]
== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts Besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

Um Speicher dynamisch (während der Laufzeit) zu reservieren, kann '''malloc()''' verwendet werden. malloc(size) "alloziert" (~reserviert) einen gewissen Speicherblock mit '''size''' Bytes. Ist kein Platz für den neuen Block, wird NULL (0) zurückgegeben.

Wird der angelegte Block zu klein (groß), kann die Größe mit realloc() verändert werden. Den allozierten Speicherbereich kann man mit free() wieder freigeben. Wenn das Freigeben eines Blocks vergessen wird spricht man von einem "Speicherleck" (memory leak).

malloc() legt Speicherblöcke im '''Heap''' an, belegt man zuviel Platz, dann wächst der Heap zu weit nach oben und überschreibt den Stack, und der Controller kommt in Teufels Küche. Das kann leider nicht nur passieren wenn man insgesamt zu viel Speicher anfordert, sondern auch wenn man Blöcke unterschiedlicher Größe in ungünstiger Reihenfolge alloziert/freigibt (siehe Artikel [[Heap-Fragmentierung]]). Aus diesem Grund sollte man malloc() auf Mikrocontrollern sehr sparsam (am besten gar nicht) verwenden.

Beispiel zur Verwendung von malloc():
<c>
#include <stdlib.h>

void foo(void) {
// neuen speicherbereich anlegen,
// platz für 10 uint16
uint16_t* pBuffer = malloc(10 * sizeof(uint16_t));

// darauf zugreifen, als wärs ein gewohnter Buffer
pBuffer[2] = 5;

// Speicher (unbedingt!) wieder freigeben
free(pBuffer);
}
</c>

Wenn (wie in obigem Beispiel) dynamischer Speicher nur für die Dauer einer Funktion benötigt und am Ende wieder freigegeben wird, bietet es sich an, statt malloc() '''alloca()''' zu verwenden. Der Unterschied zu malloc() ist, dass der Speicher auf dem Stack reserviert wird, und beim Verlassen der Funktion automatisch wieder freigegeben wird. Es kann somit kein Speicherleck und keine Fragmentierung entstehen.

siehe auch:
* http://www.nongnu.org/avr-libc/user-manual/malloc.html

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich, um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory, bei AVR Controllern mit mehr als 64kB Flash auch elpm). Die Standard-Laufzeitbibliothek des avr-gcc (die avr-libc) stellt diese Funktionen nach Einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Lokale Variablen (eigentlich Konstanten) innerhalb von Funktionen können ebenfalls im Programmspeicher abgelegt werden. Dazu ist bei der Definition jedoch ein ''static'' voranzustellen, da solche "Variablen" nicht auf dem Stack bzw. (bei Optimierung) in Registern verwaltet werden können. Der Compiler "wirft" eine Warnung falls static fehlt.

<c>
#include <stdint.h>
#include <avr/pgmspace.h>

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Array */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t * const pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t * const pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray2 };

void foo(void)
{
static const uint8_t pgmTestByteLocal PROGMEM = 0x55;
static const char pgmTestStringLocal[] PROGMEM = "im Flash";
// so nicht (static fehlt)
// char pgmTestStringLocalFalsch [] PROGMEM = "so nicht";
}
</c>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<c>
#include <avr/pgmspace.h>

const uint8_t pgmFooByte PROGMEM = 123;
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3, 70 };

void foo (void)
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte (&pgmFooByte);
// myByte hat nun den Wert 123

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (&pgmFooByteArray1[i]);
// mach was mit myByte
}
</c>

=== Wort lesen ===

Für "einfache" 16-Bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion <code>pgm_read_word</code>:

<c>
const uint16_t pgmFooWort PROGMEM = 12345;

uint16_t myWord = pgm_read_word (&pgmFooWort);
</c>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "groß".
Damit ist der mögliche Speicherbereich für "Flash-Konstanten" auf 64kB begrenzt.<ref>Einige avr-libc/pgmspace-Funktionen ermöglichen den Lesezugriff auf den gesamten Flash-Speicher, intern via Assembler Anweisung ELPM. Die Initialisierungswerte des Speicherinhalts jenseits der 64kB-Marke müssen dann jedoch auf anderem Weg angelegt werden, d.h. nicht per PROGMEM; evtl. eigene Section und Linker-Optionen. Alt und nicht ganz korrekt: Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.</ref>

<c>
const uint8_t *ptrToArray;

ptrToArray = (const uint8_t*) pgm_read_word (&pgmPointerToArray1);
// ptrToArray enthält nun die Startadresse des Byte-Arrays pgmFooByteArray1
// Allerdings würde ein direkter Zugriff mit diesem Pointer (z. B. temp=*ptrToArray)
// nicht den Inhalt von pgmFooByteArray1[0] liefern, sondern von einer Speicherstelle
// im RAM, die die gleiche Adresse hat wie pgmFooByteArray1[0]
// Daher muss nun die Funktion pgm_read_byte() benutzt werden, die die in ptrToArray
// enthaltene Adresse benutzt und auf das Flash zugreift.

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (ptrToArray+i);
// mach was mit myByte... (18, 3, 70)
}

ptrToArray = (const uint8_t*) pgm_read_word (&pgmPointerArray[1]);

// ptrToArray enthält nun die Adresse des ersten Elements des Byte-Arrays pgmFooByteArray2
// da im zweiten Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmFooByteArray2 abgelegt ist

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (ptrToArray+i);
// mach was mit myByte... (30, 7, 79)
}
</c>

=== Block lesen ===
In den Standard-Flash Funktionen ist keine der pgm_read_xxxx Nomenklatur folgenden Funktion enthalten, die einen kompletten Block ausliest. Die enstprechende Funktion ist eine Variante von memcpy und heißt memcpy_P().

Was diese Funktion im Prinzip macht, ist einfach in einer Schleife pgm_read_byte zu benutzen, um einen Speicherblock von der Quelladresse im Flash an eine Zieladresse im SRAM zu kopieren.

<c>
void pgm_read_block( uint8_t* pTarget, const uint8_t* pSource, size_t len )
{
size_t i;

for( i = 0; i < len; ++i )
*pTarget++ = pgm_read_byte( pSource++ );
}
</c>

Damit ist es dann natürlich kein Problem mehr ganze Arrays oder Strukturen aus dem Flash in das SRAM zu übertragen.

=== Strings lesen ===
Strings sind in C nichts anderes als eine Abfolge von Zeichen. Der prinzipielle Weg ist daher identisch zu "Bytes lesen", wobei allerdings auf die [http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F Besonderheiten von Strings] wie 0-Terminierung geachtet werden muss, bzw. diese zur Steuerung einer Schleife über die Zeichen im String ausgenutzt werden kann

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hello world";

int main()
{
char c;
const char* addr;

addr = pgmString;
while (c = pgm_read_byte (addr++), c != '\0')
{
// mach was mit c
}
}
</c>

Zur Unterstützung des Programmierers steht das Repertoir der str-Funktionen auch in jeweils eine Variante zur Verfügung, die mit dem Flash-Speicher arbeiten kann. Die Funktionsnamen tragen den Suffix <tt>_P</tt>.

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hallo world";

void foo (void)
{
char string[40];

strcpy_P (string, pgmString);
}
</c>

=== Float lesen ===

Auch um floats zu lesen gibt es ein Makro:

<c>
float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};

void read_float (void)
{
int i;
float f;

for (i=0; i<3; i++)
{
// entspricht f = pgmFloatArray[i];
f = pgm_read_float (&pgmFloatArray[i]);
// mach was mit f
}
}
</c>

TODO: Beispiele für structs und pointer aus Flash auf struct im Flash (menues, state-machines etc.). Eine kleine Einleitung insbesondere auch in Bezug auf die auftretenden Schwierigkeiten liefert [http://www.mail-archive.com/avr-gcc-list@nongnu.org/msg05652.html].

=== Array aus Strings im Flash-Speicher ===

Arrays aus Strings im Flash-Speicher werden in zwei Schritten angelegt: Zuerst die einzelnen Elemente des Arrays und im Anschluss ein Array, in dem die Startaddressen der Strings abgelegt werden. Zum Auslesen wird zuerst die Adresse des i-ten Elements aus dem Array im Flash-Speicher gelesen, die im Anschluss dazu genutzt wird, auf das Element (den String) selbst zuzugreifen.

<c>
#include <stdint.h>
#include <avr/pgmspace.h>

const char str1[] PROGMEM = "first_A";
const char str2[] PROGMEM = "second_A";
const char str3[] PROGMEM = "third_A";

const char * const strarray1[] PROGMEM =
{
str1,
str2,
str3
};

static char work[20];

void read_strings (void)
{
size_t i;

for (i = 0; i < sizeof (strarray1) / sizeof (strarray1[0]); i++)
{
size_t j, len;

// setze Pointer auf die Addresse des i-ten Elements des
// Flash-Arrays (str1, str2, ...)
const char *pstrflash = (const char*) pgm_read_word (&strarray1[i]);

// kopiere den Inhalt der Zeichenkette von der
// in pstrflash abgelegten Adresse in das work-Array
// analog zu strcpy( work, strarray1[i]) wenn alles im RAM
strcpy_P (work, pstrflash);

// Gleichbedeutend damit:
strcpy_P (work, (const char*) pgm_read_word (&strarray1[i]));

// Zeichen-fuer-Zeichen
len = strlen_P (&strarray1[i]);

// <= da auch das Stringende-Zeichen kopiert werden soll
for (j = 0; j <= len; j++)
{
// analog zu work[j] = strarray[i][j] wenn alles im RAM
work[i] = (char) pgm_read_byte (pstrflash++);
}
}
}
</c>

Siehe dazu auch die avr-libc FAQ: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_rom_array How do I put an array of strings completely in ROM?]

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<c>
#include <string.h>
#include <avr/pgmspace.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann";
char StringImRam[MAXLEN];

void read_string (void)
{
strcpy (StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P (StringImRam, StringImFlash, 5))
{
// mach was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else
{
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P (StringImRam, PSTR("Mueller-Schmitt"), 5))
{
// der Code hier wird ausgefuehrt, wenn die ersten
// 5 Zeichen uebereinstimmen
}
else
{
// wird bei Nicht-Uebereinstimmung ausgefuehrt
}
}
</c>

Aber Vorsicht: Ersetzt man zum Beispiel
<c>
// Daten im "Flash"
const char flashText[] PROGMEM = "mit[]";
</c>
durch
<c>
// Hier wird "mit*" im RAM angelegt und flashPointer
// enthaelt die Adresse
const char* const flashPointer PROGMEM = "mit*";
</c>
dann kann es zu Problemen kommen.

Übergibt man Zeichenketten, die im Flash abglegt sind an eine Funktion – also die Adresse des ersten Zeichens – so muss die Funktion entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden, ob es sich um eine Flash-Adresse oder ein RAM-Adresse handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen, die Flash-Adressen erwarten, mit dem Suffix <code>_P</code> versehen sind.

Eine Funktion, die einen im Flash abgelegten String z. B. an eine UART ausgibt, würde dann so aussehen:

<c>
void uart_puts_p (const char *text)
{
char zeichen;

while ((zeichen = pgm_read_byte (text)))
{
// so lange, wie mittels pgm_read_byte nicht das Stringende
// gelesen wurde: gib dieses Zeichen aus

uart_putc (zeichen);
text++;
}
}
</c>

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<c>
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
extern void lcd_puts_p (const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))

// in einer Anwendung
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

const char StringImFlash[] PROGMEM = "Erwin Lindemann";

void my_write (void)
{
lcd_puts_p (StringImFlash);
lcd_puts_P ("Dr. Kloebner");
}</c>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option – auch bekannt als [[Bootloader]]-Support – können Teile des Flash-Speichers vom Anwendungsprogramm beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktion in einem besonderen Speicherbereich, der boot-section des Programmspeichers/Flash, abgelegt ist.

Bei einigen kleinen AVRs gibt es keine gesonderte Boot-Section, bei diesen kann der Flashspeicher von jeder Stelle des Programms geschrieben werden. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

Siehe auch:
* Forumsbeitrag [http://www.mikrocontroller.net/topic/163632#1561622 Daten in Programmspeicher speichern]

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so kompliziert ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.

Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette, z. B. 0x01fe, weiß die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert, also dem Zahlenwert, kann nicht auf den Ort der Ablage geschlossen werden.

Einige AVR-Compiler bilden die Harvard-Architektur ab, indem sie in einen Pointer nicht nur die Adresse speichern, sondern auch den Ablageort wie ''Flash'' oder ''RAM''. In einem Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch auch Nachteile, denn bei jedem Zugriff über einen Zeiger muss zur ''Laufzeit'' entschieden werden, wie der Zugriff auszuführen ist und entsprechend länglicher und langsamer kann Code ausgeführt werden.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Möchte man Werte aus einem Programm heraus so speichern, dass sie auch nach dem Abschalten der Versorgungsspannung noch vorhanden sind und nach dem Wiederherstellen der Versorgungsspannung bei erneutem Programmstart wieder zur Verfügung stehen, dann benutzt man das EEPROM.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h der avr-libc definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit), Fließkommawerte (16-bit, single-precision, float) und Datenblöcke geschrieben und gelesen werden.

Diese Funktionen kümmern sich auch um diverse Details, die bei der Benutzung des EEPROMS normalerweise notwendig sind:
* EEPROM Operationen sind im Vergleich relativ langsam. Man muss daher darauf achten, dass eine vorhergehende Operation abgeschlossen ist, ehe die nächste Operation mit dem EEPROM gestartet wird. Die in der avr-libc implementierten Funktionen aus eeprom.h berücksichtigten dies. Soll beim Aufruf einer EEPROM-Funktion sicher gestellt werden, dass diese nicht intern in einer Warteschleife auf den Abschluss der vorherigen Operation wartet, kann vorher per eeprom_is_ready testen, ob der Zugriff auf den EEPROM-Speicher sofort möglich ist.
* Es ist darauf zu achten, dass die EEPROM Funktionen nicht durch einen Interrupt unterbrochen werden können. Einige Phasen des Zugriffs sind zeitkritisch und müssen in einer definierten Anzahl Takte durchgeführt werden. Durch einen unterbrechenden Interrupt würde diese Restriktion nicht mehr eingehalten. Auch dieses Detail wird von den avr-libc Funktionen berücksichtigt, so dass man sich als C Programmierer nicht darum kümmern muss. Innerhalb der Funktionen werden Interrupts vor der "EEPROM-Sequenz" global deaktiviert und im Anschluss, falls vorher auch schon eingeschaltet, wieder aktiviert.

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert. Dies gilt für jede einzelne Zelle.

Bei geschickter Programmierung (z. B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmäßig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den gesamten EEPROM-Speicher, erreichen. Auf jeden Fall sollte man aber eine Abschätzung über die zu erwartende Lebensdauer des EEPROM durchführen. Wird ein Wert im EEPROM im Durchschnitt nur einmal pro Woche verändert, wird die garantierte Anzahl der Schreibzyklen innerhalb der voraussichtlichen Verwendungszeit des Controllers wahrscheinlich nicht erreicht. In diesem Fall lohnt es sich daher nicht, erweiterte Programmfunktionen zu implementieren, mit denen die Anzahl der Schreibzugriffe minimiert wird.

Eine weitere Möglichkeit Schreibzyklen einzusparen besteht darin, dass geprüft wird, ob im EEPROM bereits der zu speichernde Wert enthalten ist und nur veränderte Werte zu schreiben. In aktuelleren Versionen der avr-libc sind bereits Funktionen enthalten, die solche Prüfungen enthalten (eeprom_update_*).

Lesezugriffe können beliebig oft durchgeführt werden. Sie unterliegen keinen Einschränkungen in Bezug auf deren Anzahl.

=== EEMEM ===
Um eine Variable im EEPROM anzulegen, stellt die avr-libc das Makro EEMEM zur Verfügung<ref>In älteren Versionen der avr-libc ist EEMEM noch nicht vorhanden, und man kann sich folgendermassen behelfen:
<c>
#include <avr/eeprom.h>

#ifndef EEMEM
#define EEMEM __attribute__((section (".eeprom")))
#endif
</c></ref>

<c>
#include <stdint.h>
#include <avr/eeprom.h>

/* Byte */
uint8_t eeFooByte EEMEM = 123;

/* Wort */
uint16_t eeFooWord EEMEM = 12345;

/* float */
float eeFooFloat EEMEM;

/* Byte-Array */
uint8_t eeFooByteArray1[] EEMEM = { 18, 3, 70 };
uint8_t eeFooByteArray2[] EEMEM = { 30, 7, 79 };

/* 16-bit unsigned short feld */
uint16_t eeFooWordArray1[4] EEMEM;
</c>

Die grundsätzliche Vorgehensweise ist identisch zur Verwendung von PROGMEM. Auch hier erzeugt man sich spezielle attributierte Variablen (EEMEM erledigt das), die vom Compiler/Linker nicht wie normale Variablen behandelt werden. Compiler/Linker kümmern sich zwar darum, dass diesen Variablen eine Adresse zugewiesen wird, diese Adresse ist dann aber die Adresse der 'Variablen' im EEPROM. Um die dort gespeicherten Werte zu lesen bzw. zu schreiben, übergibt man diese Adresse an spezielle Funktionen, die die entsprechenden Werte aus dem EEPROM holen bzw. das EEPROM neu beschreiben.

Die mittels EEMEM erzeugten 'Variablen' sind also mehr als Platzhalter zu verstehen, denn als echte Variablen. Es geht nur darum, im C Programm symbolische Namen zur Verfügung zu haben, anstatt mit echten EEPROM Adressen hantieren zu müssen - etwas das grundsätzlich aber auch genauso gut möglich ist. Nur muss man sich in diesem Fall dann selbst darum kümmern, dass mehrere 'Variablen' ohne Überschneidung im EEPROM angeordnet werden.

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heißt eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<c>
#define EEPROM_DEF 0xFF

void eeprom_example (void)
{
uint8_t myByte;

// myByte lesen (Wert = 123)
myByte = eeprom_read_byte (&eeFooByte);

// der Wert 99 wird im EEPROM an die Adresse der
// Variablen eeFooByte geschrieben
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben

myByte = eeprom_read_byte (&eeFooByteArray1[1]);
// myByte hat nun den Wert 3

// Beispiel fuer eeprom_update_byte: die EEPROM-Zelle wird nur
// dann beschrieben, wenn deren Inhalt sich vom Parameterwert
// unterscheidet. In diesem Beispiel erfolgt also kein Schreib-
// zugriff, da die Werte gleich sind.
eeprom_update_byte(&eeFooByte, myByte);

// Beispiel zur "Sicherung" gegen leeres EEPROM nach "Chip Erase"
// (z. B. wenn die .eep-Datei nach Programmierung einer neuen Version
// des Programms nicht in den EEPROM uebertragen wurde und EESAVE
// deaktiviert ist (unprogrammed/1)
//
// Vorsicht: wenn EESAVE "programmed" ist, hilft diese Sicherung nicht
// weiter, da die Speicheraddressen in einem neuen/erweiterten Programm
// moeglicherweise verschoben wurden. An der Stelle &eeFooByte steht
// dann u.U. der Wert einer anderen Variable aus einer "alten" Version.

uint8_t fooByteDefault = 222;
if ((myByte = eeprom_read_byte (&eeFooByte)) == EEPROM_DEF)
{
myByte = fooByteDefault;
}
}
</c>

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<c>
// lesen
uint16_t myWord = eeprom_read_word (&eeFooWord);

// schreiben
eeprom_write_word (&eeFooWord, 2222);
</c>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen <code>eeprom_read_block()</code> bzw. <code>eeprom_write_block()</code>. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes als <code>size_t</code>.
<c>
uint8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

void eeprom_block_example (void)
{
/* Datenblock aus EEPROM lesen */

/* liest 3 Bytes ab der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block (myByteBuffer, eeFooByteArray1, 3);

/* dito mit etwas Absicherung betr. der Länge */
eeprom_read_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer));

/* und nun mit 16-Bit Array */
eeprom_read_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer));

/* Datenblock in EEPROM schreiben */
eeprom_write_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer));
eeprom_write_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer));
}
</c>

=== Fließkommawerte lesen/schreiben ===

In der avr-libc stehen auch EEPROM-Funktionen für Variablen des Typs float (Fließkommazahlen mit "einfacher" Genauigkeit) zur Verfügung.

<c>
#include <avr/eeprom.h>

float eeFloat EEMEM = 12.34f;

float void eeprom_float_example(float value)
{
/* float in EEPROM schreiben */
eeprom_write_float(&eeFloat, value);

/* float aus EEPROM lesen */
return eeprom_read_float(&eeFloat);
}</c>

=== EEPROM-Speicherabbild in .eep-Datei ===

Mit den zum Compiler gehörenden Werkzeugen kann der aus den Variablendeklarationen abgeleitete EEPROM-Inhalt in eine Datei geschrieben werden. Die übliche Dateiendung ist .eep, Daten im Intel Hex-Format. Damit können Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden.

Makefiles nach WinAVR/MFile-Vorlage enthalten bereits die notwendigen Einstellungen, siehe dazu die Erläuterungen im [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]].

Der Inhalt der eep-Datei muss ebenfalls zum Mikrocontroller übertragen werden, wenn die Initialisierungswerte aus der Deklaration vom Programm erwartet werden. Ansonsten enthält der EEPROM-Speicher nach der Übertragung des Programmers mittels ISP abhängig von der Einstellung der EESAVE-Fuse<ref>vgl. Datenblatt Abschnitt Fuse Bits</ref> nicht die korrekten Werte:
; EESAVE = 0 (programmed): Die Daten im EEPROM bleiben erhalten. Werden sie nicht neu geschrieben, so enthält das EEPROM evtl. Daten, die nicht mehr zum Programm passen.
; EESAVE = 1 (unprogrammed): Beim Programmieren werden die Daten im EEPROM gelöscht, also auf 0xff gesetzt.

Als Sicherung kann man im Programm nochmals die Standardwerte vorhalten, beim Lesen auf 0xFF prüfen und gegebenenfalls einen Standardwert nutzen.

=== Direkter Zugriff auf EEPROM-Adressen ===

Will man direkt auf bestimmte EEPROM Adressen zugreifen, dann sind folgende Funktionen hilfreich, um sich die Typecasts zu ersparen:

<c>
#include <avr/eeprom.h>

// Byte aus dem EEPROM lesen
uint8_t EEPReadByte(uint16_t addr)
{
return eeprom_read_byte((uint8_t *)addr);
}

// Byte in das EEPROM schreiben
void EEPWriteByte(uint16_t addr, uint8_t val)
{
eeprom_write_byte((uint8_t *)addr, val);
}
</c>

oder als Makro:

<c>
#define EEPReadByte(addr) eeprom_read_byte((uint8_t *)addr)
#define EEPWriteByte(addr, val) eeprom_write_byte((uint8_t *)addr, val)
</c>

Verwendung:

<c>
EEPWriteByte(0x20, 128); // Byte an die Adresse 0x20 schreiben
...
Val=EEPReadByte(0x20); // EEPROM-Wert von Adresse 0x20 lesen
</c>

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Bei alten Versionen der avr-libc wurden nicht alle AVR Controller unterstützt. Z.B. bei der avr-libc Version 1.2.3 insbesondere bei AVRs "der neuen Generation" (ATmega48/88/168/169) funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register). In neueren Versionen (z. B. avr-libc 1.4.3 aus WinAVR 20050125) wurde die Zahl der unterstüzten Controller deutlich erweitert und eine Methode zur leichten Anpassung an zukünftige Controller eingeführt.

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Will oder kann man nicht auf die neue Version aktualisieren, kann der dort gezeigte Code auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste", gegebenfalls Schutz vor Unterbrechnung/Interrupt ergänzen ''uint8_t sreg; sreg=SREG; cli(); [EEPROM-Code] ; SREG=sreg; return;'', siehe Abschnitt Interrupts). Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

=== EEPROM Register ===
Um das EEPROM anzusteuern, sind drei Register von Bedeutung:
;EEAR: Hier werden die Adressen eingetragen zum Schreiben oder Lesen. Dieses Register unterteilt sich nochmal in EEARH und EEARL, da in einem 8-Bit-Register keine 512 Adressen adressiert werden können.
;EEDR: Hier werden die Daten eingetragen, die geschrieben werden sollen, bzw. es enthält die gelesenen Daten.
;EECR: Ist das Kontrollregister für das EEPROM

Das EECR steuert den Zugriff auf das EEPROM und ist wie folgt aufgebaut:

:{| class="wikitable" style="text-align:center"
|+ '''Aufbau des EECR-Registers'''
|-
!Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| - || - || - ||- || EERIE || EEMWE || EEWE || EERE
|-
! Read/Write
| R || R || R || R || R/W || R/W || R/W || R/W
|-
!Init Value
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''Bedeutung der Bits'''

;Bit 4-7: nicht belegt

;Bit 3 (EERIE): ''EEPROM Ready Interrupt Enable'': Wenn das Bit gesetzt ist und globale Interrupts erlaubt sind in Register SREG (Bit 7), wird ein Interrupt ausgelöst nach Beendigung des Schreibzyklus (EEPROM Ready Interrupt). Ist einer der beiden Bits 0, wird kein Interrupt ausgelöst.

;Bit 2 EEMWE): ''EEPROM Master Write Enable'': Dieses Bit bestimmt, dass, wenn EEWE = 1 gesetzt wird (innerhalb von 4 Taktzyklen), das EEPROM beschrieben wird mit den Daten in EEDR bei Adresse EEAR. Wenn EEMWE = 0 ist und EEWE = 1 gesetzt wird, hat das keine Auswirkungen. Der Schreibvorgang wird dann nicht ausgelöst. Nach 4 Taktzyklen wird das Bit EEMWE automatisch wieder auf 0 gesetzt. Dieses Bit löst den Schreibvorgang nicht aus, es dient sozusagen als Sicherungsbit für EEWE.

;Bit 1 (EEWE): ''EEPROM Write Enable'': Dieses Bit löst den Schreibvorgang aus, wenn es auf 1 gesetzt wird, sofern vorher EEMWE gesetzt wurde und seitdem nicht mehr als 4 Taktzyklen vergangen sind. Wenn der Schreibvorgang abgeschlossen ist, wird dieses Bit automatisch wieder auf 0 gesetzt und, sofern EERIE gesetzt ist, ein Interrupt ausgelöst. Ein Schreibvorgang sieht typischerweise wie folgt aus:
:# EEPROM-Bereitschaft abwarten (EEWE=0)
:# Adresse übergeben an EEAR
:# Daten übergeben an EEDR
:# Schreibvorgang auslösen in EECR mit Bit EEMWE=1 und EEWE=1
:# (Optional) Warten, bis Schreibvorgang abgeschlossen ist

;Bit 0 EERE: ''EEPROM Read Enable'': Wird dieses Bit auf 1 gesetzt wird das EEPROM an der Adresse in EEAR ausgelesen und die Daten in EEDR gespeichert. Das EEPROM kann nicht ausgelesen werden, wenn bereits eine Schreiboperation gestartet wurde. Es ist daher zu empfehlen, die Bereitschaft vorher zu prüfen. Das EEPROM ist lesebereit, wenn das Bit EEWE=0 ist. Ist der Lesevorgang abgeschlossen, wird das Bit wieder auf 0 gesetzt, und das EEPROM ist für neue Lese- und Schreibbefehle wieder bereit. Ein typischer Lesevorgang kann wie folgt aufgebaut sein:
:# Bereitschaft zum Lesen prüfen (EEWE=0)
:# Adresse übergeben an EEAR
:# Lesezyklus auslösen mit EERE = 1
:# Warten, bis Lesevorgang abgeschlossen EERE = 0
:# Daten abholen aus EEDR

= Die Nutzung von sprintf und printf =

Um komfortabel, d.h. formatiert, Ausgaben auf ein Display oder die serielle Schnittstelle zu tätigen, bieten sich '''sprintf''' oder '''printf''' an. Alle *printf-Varianten sind jedoch ziemlich speicherintensiv und der Einsatz in einem Mikrocontroller mit knappem Speicher muss sorgsam abgewogen werden.

Bei '''sprintf''' wird die Ausgabe zunächst in einem Puffer vorbereitet und anschließend mit einfachen Funktionen zeichenweise ausgegeben. Es liegt in der Verantwortung des Programmierers, genügend Platz im Puffer für die erwarteten Zeichen bereitzuhalten.

<c>
#include <stdio.h>
#include <stdint.h>

// ...
// nicht dargestellt: Implementierung von uart_puts (vgl. Abschnitt UART)
// ...

uint16_t counter;

// Ausgabe eines unsigned Integerwertes
void uart_puti( uint16_t value )
{
uint8_t puffer[20];

sprintf( puffer, "Zählerstand: %u", value );
uart_puts( puffer );
}

int main()
{
counter = 5;

uart_puti( counter );
uart_puti( 42 );
}
</c>

Eine weitere elegante Möglichkeit besteht darin, den STREAM stdout (Standardausgabe) auf eine eigene Ausgabefunktion umzuleiten. Dazu wird dem Ausgabemechanismus der C-Bibliothek eine neue Ausgabefunktion bekannt gemacht, deren Aufgabe es ist, ein einzelnes Zeichen auszugeben. Wohin die Ausgabe dann tatsächlich stattfindet, ist Sache der Ausgabefunktion. Im Beispiel unten wird auf UART ausgegeben. Alle anderen, höheren Funktionen wie z. B. '''printf''', greifen letztendlich auf diese primitive Ausgabefunktion zurück.

<c>
#include <avr/io.h>
#include <stdio.h>

void uart_init(void);

// a. Deklaration der primitiven Ausgabefunktion
int uart_putchar(char c, FILE *stream);

// b. Umleiten der Standardausgabe stdout (Teil 1)
static FILE mystdout = FDEV_SETUP_STREAM( uart_putchar, NULL, _FDEV_SETUP_WRITE );

// c. Definition der Ausgabefunktion
int uart_putchar( char c, FILE *stream )
{
if( c == '\n' )
uart_putchar( '\r', stream );

loop_until_bit_is_set( UCSRA, UDRE );
UDR = c;
return 0;
}

void uart_init(void)
{
/* hier µC spezifischen Code zur Initialisierung */
/* des UART einfügen... s.o. im AVR-GCC-Tutorial */

// Beispiel:
//
// myAVR Board 1.5 mit externem Quarz Q1 3,6864 MHz
// 9600 Baud 8N1

#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

// Hilfsmakro zur UBRR-Berechnung ("Formel" laut Datenblatt)
#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)

UCSRB |= (1<<TXEN) | (1<<RXEN); // UART TX und RX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); // Asynchron 8N1

UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );
UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );
}

int main(void)
{
int16_t antwort = 42;
uart_init();

// b. Umleiten der Standardausgabe stdout (Teil 2)
stdout = &mystdout;

// Anwendung
printf( "Die Antwort ist %d.\n", antwort );
return 0;
}

// Quelle: avr-libc-user-manual-1.4.3.pdf, S.74
// + Ergänzungen
</c>

Sollen Fließkommazahlen ausgegeben werden, muss im Makefile eine andere (größere) Version der [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|printflib]] eingebunden werden.

= Anmerkungen =
<references/>

= TODO =
* Aktualisierung Register- und Bitbeschreibungen an aktuelle AVR
* "naked"-Funktionen

[[Kategorie:avr-gcc Tutorial| ]]

Diskussion:Elektronikversender

2012-08-28T17:01:17Z

Mthomas: Wortwahl?

Elektronikversender

2012-08-28T17:00:00Z

Mthomas: /* Waschbär Soft 2010 */

Die Vor- und Nachteile von verschiedenen Elektronik-Versand-Händlern werden relativ häufig im Forum diskutiert. Diese Diskussionen führen nicht selten zu weitestgehend gleichen Ergebnissen. In diesem Artikel sollen daher die Argumente, die für oder gegen einen bestimmten Elektronik-Versender sprechen, zusammengetragen werden. Sobald diese Liste einigermaßen vollständig ist, würde dies sicher einige Diskussions-Threads und/oder Flame-Wars überflüssig machen.

Diese Liste erhebt keinerlei Anspruch auf Vollständigkeit, d.h. wenn ihr einen Versender kennt, der hier noch nicht aufgeführt ist, dann nennt wenigstens die URL und den Namen. Den Rest können auch andere besorgen, die den Versender ebenfalls kennen!

Bitte ergänzt nur allgemeine Sachen (z. B. "liefert immer vollständig", "günstig" oder "große Auswahl"), aber nicht Sachen wie "mein ATMega 128 hatte verbogene Beine"! Bitte auch die alphabetische Sortierung beibehalten!

'''Diese Seite kann nur von angemeldeten Benutzern bearbeitet werden!'''

__TOC__

== Liste der Versender ==

=== AATiS ===
Homepage: http://www.aatis.de

* Arbeitskreis Amateurfunk und Technik in der Schule e.V.
* Bausätze speziell auch für Elektronik-Anfänger, Schüler
* Literatur, Seminare für Lehrer

=== Actron ===
Homepage: http://www.actron.de

* '''kein''' Online-Shop!
* alphanumerische LCDs und Graphikdisplays in großer Auswahl, auch mit Touchscreens
* für gewerbliche Kunden: etwas verhandeln schadet nie
* bei kleinen Stückzahlen nicht ganz billig
* liefern sehr schnell und stets zuverlässig



=== AK Modul Bus Computer GmbH ===
Homepage: http://www.ak-modul-bus.com/stat/produkte.html

* Interfaces, Messmodule, Funktionsmodelle, Experimentiersysteme
* Entwicklungssysteme, Baugruppen, Elektor, Zubehör, Bauelemente
* Software, Lernpakete, Bücher, Sonderposten

=== Allpax ===
Homepage: http://www.allpax.de

* Liefert auch an Privathaushalte
* Keine Elektronik an sich, aber ggf. nützliches Zubehör: Größeres, übersichtliches Sortiment an ESD-Beuteln und -Folien, offen und mit Zippverschluss, Pink Poly und Metallisiert (High Shield). Preislich über Farnell, dafür findet man sofort, was man sucht...
* außerdem Ultraschallreiniger, Waagen und Folienschweißgeräte, sowie viel Fachfremdes
* Versandkosten: 8,33€ nach Deutschland, diverse EU-Länder 17,85€, Schweiz 34,51€; Versandkostenfrei in D ab 178,50€
* Gewährt scheinbar auch Privatkunden die Zahlung per Rechnung; bei Bankeinzug 2% Rabatt, bei Vorkasse und Abholung 3%

=== AME-Engineering ===
Homepage: http://www.ame-engineering.de

* Hochfrequenz-Spezialitäten, Amateurfunk

=== Amidon ===
Homepage: http://www.amidon.de

* Sehr großes Sortiment, vorallem für seltene Bauteile, z. B. Dioden

=== Andy's Funkladen ===
Homepage: http://www.andyfunk.de

* Alles für Amateur- und CB-Funk
* Bauteile und Gehäuse

=== Anvilex ===
Homepage: http://shop.anvilex.com/index.html

* Liefert sehr günstige Break-Out Boards für diverse Packages
* Hat einige einfache und günstige Programmer auch für FPGAs etc

=== Atlantis Shop 24 ===
Homepage: http://www.atlantis-shop24.de

* Elektronik nur ein kleiner Teil des Angebotes. Ansonsten eher Drogerie bzw. Haushaltsbedarf

=== Atzert-Elektronik Versand ===
Homepage: http://www.atzert-elektronik.de

Früher ''EFB-Electronic Versand'', davor ''MEGAKICK Electronic Stores''.

* Mindestens schon der dritte Name und die dritte Webseite für den Endkunden-Versand von [[Elektronikversender#ETT|ETT]]. ETT liefert sonst nur an gewerbliche Kunden.
* Ladengeschäfte in Bielefeld, Braunschweig, Bremen, Hamburg und Berlin.
* Die Preise schwanken im Vergleich zu anderen Anbietern, welche ebenfalls ETT-importierte Produkte führen, mal nach oben, mal nach unten.

=== Bassenberg Elektronik ===
Homepage: http://www.bassenberg.de

* Ladengeschäfte in Braunschweig und Neumünster
* Beschafft auch nicht mehr gelistete und abgekündigte Bauteile
* Liefert auch an Privat

=== Batronix ===
Homepage: http://www.batronix.com
* Grosses Sortiment an Geräten
* Bausätze für Microcontroller-Applikationen
* Liefert auch an Privat

=== BAZ Spezialantennen ===
Homepage: http://www.spezialantennen.de

* Antennen für Amateurfunk, ISM, WLAN usw.

=== bed - elektronik ===
Homepage: http://www.bed-elektronik.de

* Restposten aktive und passive Bauelemente
* sehr günstige Preise
* alles ab Lager lieferbar
* Versand an Privat
* ab 60 EUR versandkostenfrei

=== Bfi-Optilas ===
Homepage: http://www.bfioptilas.de

* Kein Onlineshop
* spezialisierter Distributor für Hochfrequenzhalbleiter und Optik

=== BG-Electronics.de ===
Homepage: http://www.bg-electronics.de

* Online Shop für aktive und passive elektronische Bauelememte
* günstige Preise
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, CarHiFi und TV-Bereich



=== Box73 ===
Homepage: http://www.box73.de

Onlineshop des Funkamateur.

* Bauteile, Bausätze, Literatur aus dem Amateurfunkbereich
* Preise sind O.K.
* Bestellungen werden nur Di und Do bearbeitet
* Ab 50 EUR bei Bankeinzug portofrei.

=== Bürklin OHG ===
Homepage: http://www.buerklin.com

* große Auswahl, hohe Verfügbarkeit
* sehr schneller Versand
* Ladengeschäft in Oberhaching (südlicher Landkreis München)
* <s>nur an gewerbliche Abnehmer (lt. AGB), private Abnehmer können dennoch im Ladengeschäft einkaufen Angeblich versendet Bürklin seit November 2010 auch an Privatpersonen. Allerdings verlangt Bürklin weiterhin in Adressformularen die Eingabe eines Firmennamens Geben Sie einen Wert in das Feld "Firma" ein. Daher ist diese Information eher mit Vorsicht zu genießen.</s> Mittlerweile muss man auch keinen Firmennamen mehr eingeben. Die AGB wurde ebenfalls angepasst.
* 35 EUR Mindestbestellwert (incl. MwSt), darunter 7 EUR Bearbeitungskosten

=== CBsoft, s.r.o. (ltd.) ===
*Homepage: http://www.jjtubes.eu/
* Firma in der Slowakei
* Verkauft Röhren der Firma JJ
* englischsprachig
* Zahlungsmöglichkeiten in € mit Paypal und Kreditkarte

=== chiptrade.com ===
siehe [[#SE Spezial-Electronic AG|SE Spezial-Electronic AG]]

=== ConeleK Electronic ===
Homepage: http://www.conelek.com

* Sehr kleines Bauteileangebot (Röhren, Röhrensockel)
* Elektronik-Laborbedarf, insbesondere Nachfüllpackungen mit Steckbrett-Drahtbrücken
* Werkzeug für Elektronik
* Stromversorgungen
* Versand an Privat
* Versandkosten bis 25kg, Vorkasse 5,90€ (Stand 04/2008)

=== Conrad ===
Homepage: http://www.conrad.de und http://www.business.conrad.de

* großes Angebot (für Bauteile den "Business"-Katalog beachten, der Hauptkatalog ist dahingehend etwas "dünn") (Anm.: Bauteile, die nur im Business-Katalog aufgeführt sind, sind in Ladengeschäften nur über Sonderbestellung zu bekommen, d.h. dort in aller Regel nicht vorrätig.)
* Positiv: Wirklich jedes Bauteil kann einzeln gekauft werden und wird nicht in dämlichen Verpackungseinheiten verkauft, so wie es bei den meisten anderen Elektronik-Lieferanten der Fall ist. Dies ist vor Allem für den Prototypenbau sehr hilfreich.
* relativ teuer jedoch bis zu 10% Rabatt für Schulen (bei genügend Umsatz)
* 21 Ladengeschäfte in Deutschland, fünf in Österreich
* positiv: Bei Business-Kunden wird der Rechnungsbetrag erst nach 14 Tagen abgebucht.
* haben einen (teuren) 24 Std. Lieferservice für Notfälle - Conrad garantiert aber nicht 100%ig für die Einhaltung der 24 Stunden. Bei Nichteinhaltung gibt es kein Geld zurück.
* Verfügbarkeit in Filialen kann Online überprüft werden.
* Verfügbarkeit in Filialen kann über zentale Rufnummer erfragt werden. Abholung bestellter Ware in Filialen möglich, aber trotzdem gleiche Versandkosten.


=== csd-electronics ===
Homepage: [http://www.csd-electronics.de csd-electronics.de]

* ATMEL, ICs, Passive und Mechanische Bauteile, Platinen- und Lötzubehör, u.a.
* ca. 4000 Bauteile lagernd
* günstig
* Mengenrabatte für fast jedes Produkt
* Versand innerhalb Deutschlands:
* DPD: 3,75€ (ab 50 EUR versandkostenfrei)
* DHL: 4,50€ (ab 100 EUR versandkostenfrei)
* Versand EU-weit ab 5,95 EUR
* kein Mindestbestellwert
* schnelle Lieferung, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage beschafft werden.
* Zahlung per Vorkasse (2% Skonto), PayPal, Nachnahme. 1 EUR Aufschlag bei PayPal-Zahlung
* Zahlung per Bankabbuchung, Kreditkarte oder Rechnung nur für Stammkunden (ab 4 bis 5 Bestellung), Für Institute/Firmen direkt auf Rechnung möglich
* haben ein Forum, in dem man sich zu Sammelbestellungen organisieren kann und auch allgemeine Fragen stellen kann -zur Zeit (05/2008) offline-

=== dad24 ===
Homepage, Shop: http://dad24.eu
E-Bay Shop: http://stores.ebay.de/Shop-dad24

* Unterschiedliche Preise in den beiden Shops
* Kleiner, nicht sonderlich schöner Onlineshop (dad24.eu)
* Kleines Angebot. Lupenleuchten, Lötstationen, Labornetzgeräte, Messgeräte, etc. aus dem unteren Preissegment
* Jede Woche eine neue "Kategorie der Woche" auf dad24.eu. Produkte aus der Kategorie werden erst im Warenkorb mit einem Rabatt angezeigt, der auch gewährt wird.

=== Darisus ===
Homepage: http://www.darisus.de

* kompetente Beratung
* liefert sehr zuverlässig, in Notfällen auch Express
* Versand innerhalb Deutschlands ab 4,50 EUR
* Hat auch eine gute Auswahl an CPLDs und einige FPGAs diverser Hersteller

=== Daschke LTD ===
PDF-Katalog (Achtung, grosse Datei): http://www.daschke-ltd.de/Catalog/

* Prompte Antwort und Hilfe via info ät obige adresse
* Bezahlung per Paypal und Rechnung möglich. Ist auch Ebay-Händler.
* sehr faire Preise für Bauteile und Versand
* Führt eine Vielzahl an unüblichen Steckern und Buchsen
* Nicht verfügbare Bauteile wurden proaktiv nachbestellt, trotz geringer Bestellmenge. Prima!

=== DES - Der Elektroniker-Shop ===
Homepage: http://www.DerElektronikerShop.de

* Bauteile
* Bauteilsätze der [http://www.DieElektronikerseite.de Elektronikerseite]
* Verkauf des BasicBeetle und Zubehör von [http://www.DieProjektseite.de der Projektseite]
* Ständig wachsendes Angebot
* Auch einige SMD-Bauteile verfügbar
* Kein Mindestbestellwert
* Versandkosten ab 3,50 EUR (Österreich/Europa ab 4,00 Eur)
* Versand auch nach Österreich (Europa auf Anfrage)
* Zahlung per Vorkasse
* Lieferzeit 1-3 Tage bei Verfügbarkeit
* PrePaid-Konto möglich
* Lieferungen auch an Privat

=== Digi-Key ===
(tlw.) deutsche Homepage: http://de.digikey.com

* optisch nicht besonders ansprechende, aber durchaus sehr funktionelle Website
* beheimatet in den USA, ein Logistikbüro gibt es in den Niederlanden
* kostenloser Versand ab 65€, darunter 18€ Versandkosten
* macht merkwürdige Plausibilitäts-Checks: wenn man privat über ihrem Dollar Limit (z.B. 400 Dollar bestellt) kommt sofort die Rückfrage nach Firmenname und Firmenadresse
* Rückfragen nach dem Verwendungszweck kommen ebenfalls schon bei der Bestellung bei bestimmten Bauteilen die der Exportkontrolle unterliegen
* Versand direkt aus den USA, dafür sehr flott mit UPS Express (in rund zwei bis drei Tagen da)
* riesiges Angebot, gewissermaßen ein Distributor der auch Kleinmengen an Privatpersonen liefert, entscheidend ist, dass der Hersteller des Produkts geführt wird
* kein anderer Anbieter, bietet so viele verschiedene passive Bauteile in kleinen Stückzahlen, z. B. SMD Widerstände in Bauform 01005 bis 2512 meist in verschiedenen Toleranzklassen und von verschiedenen Herstellern
* alle Bauteile mit Herstellerangabe, Digikey kauft ausschließlich direkt vom Hersteller
* Preise sind auf der deutschen Website in Euro inklusive etwaigem Zoll angegeben, allerdings ohne Mehrwertsteuer, die korrekt abgerechnet wird (d.h. man zahlt bei Versand nach Österreich 20% Mwst., nach Deutschland m.W.n. 19%)
* Meistens deutlich teurer als Reichelt, doch häufig die beste Anlaufstelle für Privatkunden wenn es um Spezialbauteile geht, und der Hersteller sich im Programm von Digikey befindet

* Zu beachten ist auch noch folgendes, um unliebsame zusatzkosten zu vermeiden: http://www.mikrocontroller.net/topic/90943#new. ''Anmerkung dazu: Digikey hat wohl zum 1.4.2011 den Versand umgestellt und importiert nun selbst. Zusatzkosten durch Verzollung sollten dann nicht mehr anfallen.''

=== Display Electronics ===

Homepage: http://www.distel.co.uk

* In England
* Webseite = Augenkrebs
* Online-Shop versteckt hinter dem Search-Button auf der Homepage
* Restposten aller Art
* Mindestbestellwert 10 GBP

=== eHaJo ===
Homepage: http://www.eHaJo.de

* Bausätze
* Lötübungen
* AVR-ISP-Stick

=== Eisch-Kafka-Electronic ===
Homepage: http://www.eisch-electronic.de

* Hochfrequenz Bausätze und Bauteile für Amateurfunk

=== EleConT ===
Homepage: http://www.elecont.de/shop/

* Carrierboards für gebräuchliche AVR

=== Electropuces ===
Homepage: http://perso.wanadoo.fr/electropuces/

* Gebrauchte Messgeräte aus Nantes, Frankreich (teilweise engl. Menü)

=== Electronic Search ===

Homepage: http://www.electronic-search.de

* Keine Mindestbestellmenge
* Verkauf auch an Privat/Bastler
* Fast alle Preise im Online-Shop nur "auf Anfrage", und nicht im Shop angegeben.

=== electronicpool Rheinstetten ===
Homepage: http://www.electronicpool.de

* abgekündigte oder schwer beschaffbare elektronische Bauteile

=== Elektronikladen ===
Homepage: http://www.elektronikladen.de

* Spezialist für Mikrokontroller
* Entwicklungssysteme, keine Einzelbauteile
* entsprechende Literatur und Software
* "Kein Verkauf an Endverbraucher i.S.d. §13 BGB"

=== Elektronik-Kompendium ===
Homepage: http://www.elektronik-kompendium.de

* Bausätze diverser Schaltungen (mit Anleitung und Funktionsbeschreibung)
* erspart lästiges Suchen in anderen Shops
* kurze Lieferzeiten
* günstiger Versand

=== Elk Tronic ===
Homepage: http://www.elk-tronic.de

* kleines Lieferprogramm Adapterplatinen (SMD -> 2,54mm-Raster) und Programmieradapter
* günstige Preise und Versandspesen

=== Elko-Verkauf ===
Homepage: http://www.elko-verkauf.de

* Nur Low-ESR-Elkos
* Elko-Sets für ein Gerät

=== Ellmitron ===
Homepage: http://www.ellmitron.de/
Katalog: http://www.ellmitron.de/katalog.pdf

Lehrmittel, Kleinbausätze vor allem für Schüler, Experimentierkästen

=== Elpro Darmstadt ===
Homepage: http://www.elpro.org

* Kein Mindestbestellwert, aber hohe Versandkosten für kleine Bestellungen. Stand September 2008:
** Bis 15€: 9,95€ Versandkosten
** Von €15 bis €75: 5,95€ Versandkosten
** Von €75 bis €200: 4,49€ Versandkosten
** Ab €200: Versandkostenfrei
* Große Auswahl an Mikrocontrollern
* Sehr große Auswahl an Schaltnetzteilen von Meanwell (geschlossen, offen, auf PCB lötbar, DIN-Schiene)
* Merkwürdig zu bedienende Shopsoftware, ständig klappt was auf und zu und wird irgendwas nachgeladen. Braucht JavaScript
* Keine AGBs online. Da Preisangaben ohne MwSt. richtet sich das Angebot vermutlich nicht an Endverbraucher (werden aber beliefert)
* Bearbeitungszeit (bis Warenausgang) 2-3 Tage.
* Versand bisher mit DHL
* gute bis sehr gute Verpackung

=== Eltrix ===
Homepage: http://eltrix.de/Starteltrix.htm

* Verbrauchsmaterial, Tipps und Tricks fürs Leiterplattenherstellen und Löten

=== ELV ===
Homepage: http://www.elv.de

* nicht sehr große Auswahl an Einzelteilen
* riesiges Angebot an Zubehör für Hobbyisten
* viele z.T. pfiffige Eigenentwicklungen, Bausätze (auch zum Download auf der Website verfügbar)
* sonst Sortiment ähnlich Conrad, nicht billig
* im Allgemeinen nicht billig, merkwürdigerweise sind manche Artikel aber die günstigsten auf dem Markt
* mühsamer Onlinekatalog
* Immer mal wieder Fehllieferungen und Wartezeiten (zumindest in die Schweiz). Service erreichte in 3 Fällen nicht das inserierte Niveau.
* Versandkosten innerhalb Deutschland 4,5€, ab 150€ Bestellwert versandkostenfrei
* nicht abwählbare Versandversicherung, die 0,85% des Bestellwertes kostet



=== ETT - Electronic Toys Trading ===
Homepage: http://www.ett-online.de

* Großhandel nur für Gewerbekunden.
* Zweitshop [[Elektronikversender#Atzert-Elektronik_Versand|Atzert-Elektronik Versand]] (früher EFB-Electronic Versand, davor Megakick Electronic-Stores) für Endkunden.
* Ladengeschäft in Braunschweig für jedermann. Weitere Atzert Ladengeschäfte in Bielefeld, Bremen, Hamburg und Berlin.
* Eigentümer der Marken McCHECK®, McPower®, McVoice® und anderer, unter denen ETT importierte Messgeräte, Labornetzteile, usw. an Großkunden und Händler vertreibt. Diese sind unter oben genannten Marken dann in vielen Shops anderer Firmen für Endkunden zu finden, nicht nur bei Atzert. Preisvergleiche lohnen.

=== Ettinger GmbH ===
Homepage: http://www.ettinger.de

* Für gewerbliche Kunden
* Mechanische Komponenten (Gehäuse, Abstandshalter, Drehknöpfe, usw.)
* LEDs
* Gewöhnungsbedürftiger Online-Shop

=== EVE ===
Homepage: http://www.eve.de

* Zitat aus den AGBs:
::''"Zu Bestellungen im Rahmen des Online-Handels sind nur durch uns autorisierte, d. h. zugelassene Käufer berechtigt. Wir gewähren nach erfolgreicher Zertifizierung – ohne hierzu verpflichtet zu sein – dem jeweiligen Käufer das nicht übertragbare, nicht exklusive Recht im Rahmen des Online-Handels Bestellungen uns gegenüber “auszubringen”."''

:Dies darf man wohl getrost als Hinweis ansehen, dass Endverbraucher als Kunden nicht gewünscht sind.
* Versandhaus für elektronische Artikel in Emsdetten
* machen auch Kabelkonfektion
* Pb-freie Artikel markiert

=== Farnell ===
Homepage: http://de.farnell.com

* liefert nur an gewerbliche Abnehmer, Ausnahme sind Studenten und HTL-Schüler (Österreich, Farnell.at). Nachweis wird verlangt (Gewerbeschein oder Immatrikulation).
* Lieferungen an Privat:
:* Schweiz: Farnell Schweiz beliefert auch Privatkunden.
:* Deutschland: Über den Reseller [[#HBE_-_Heinz_B.C3.BCchner_Elektronik.2C_Messtechnik.2C_med._Elektronik_e.K.|HBE]] kann man Produkte aus dem Farnell-Sortiment zu bestellen.
:* Österreich: [[#Technik-Welt / Industrieshop.at|Technik-Welt / Industrieshop.at]]
* große Auswahl
* 12% Rabatt für Studenten und Lehreinrichtungen
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (UPS), fehlende Positionen werden relativ rasch versandkostenfrei nachgeliefert
* Versandkosten: Bestellung bis 49,99€: 7,95€; 50,- bis 149,99€: 5,95€; ab EUR 150,- versandkostenfrei
* hat nach eigenen Aussagen umfangreichstes Sortiment an RoHS-konformen Bauteilen mit Suchfunktion im WWW
* leistungsfähige parametrische Suchfunktion / teils aber völlig nutzlos, da den Artikeln massenweise Tags fehlen, weswegen die Suchergebnisse unnötig eingeschränkt werden
* Datenblätter für die meisten Bauteile online
* Internetpräsenz fällt nachts oft aus (Hinweis auf angebliche geplante Wartungsarbeiten)
* Sortierfunktion wird bei der Suche ständig zurückgesetzt, im Warenkorb ist überhaupt keine sinnvolle Sortierung möglich
* Eigenwillige Preispolitik: Einiges sehr günstig, Anderes total überteuert

=== Fibra-Brandt Zweibrücken ===
Homepage: http://www.fibra-brandt.com

* lagert tausende veraltete und schwer zu findende elektronische Bauteile
* Halbleiter, IC's, Transistoren, Spulen und Kondensatoren.
* Sonderbeschaffung von abgekündigten Halbleitern.

=== Fischer DK2FD ===
Homepage: http://www.dfe-online.de

* Baugruppen für Hochfrequenzmesstechnik und Amateurfunk

=== Funkamateur Online-Shop ===

Siehe [[Elektronikversender#Box73]]

=== Futurelec ===
Homepage: http://www.futurlec.com

* günstiger Versender aus Übersee
* viele Stamp-Boards
* LED Matrix-Module

=== Future Electronics ===
Homepage: http://de.futureelectronics.com

* große Auswahl an Teilen
* Versand auch an Privatpersonen
* Preisangaben ohne MwSt.
* Zahlung nur mit Kreditkarte
* Versandkosten 7,14€ (Brutto)
* Versand aus den USA mit FedEx, Lieferzeit meist unter 5AT
* Verzollung usw. wird von FutureElectronics gemacht, keine Nachzahlungen etc.

=== Geist Electronic-Versand GmbH ===
Homepage: http://www.geist-electronic.de

* Liefern Bauteile für Elektor-Projekte
* D-78054 Villingen-Schwenningen
* Versandkosten: 5.40€

=== Giga-Tech ===
Homepage: http://www.giga-tech.de

* Spezialitäten für Hochfrequenz / Amateurfunk
* 68542 Heddesheim

=== Grummes Elektronik ===
Homepage: http://www.grummes.de

* Elektronikversender /CNC-Fräsmaschinen / Schrittmotorsteuerungen / Bauteile
* Homepage nicht aufrufbar (10.12.2011)

=== Glyn (GLYNshop) ===
Homepage: https://www.glynshop.com/erp/welcome.do

* "B2B Shop" = nicht für Privatkunden
* Microcontroller, Evaluation Boards, TFT-Displays, LC-Displays, Memory Cards u.a.

=== guloshop.de ===
Homepage: http://guloshop.de

* kleiner Shop, konzentriert sich auf Standard-AVRs im DIP-Gehäuse, ist dabei aber meist der billigste Versender in Deutschland
* ATtiny, ATmega, Breakout-Boards, Programmer, Adapterkabel, IC-Fassungen
* AVR mit geflashtem Arduino-Bootloader
* äußerst niedrige Preise
* liefert schnell und zuverlässig, jedoch nur gegen Vorkasse
* kein Mindestbestellwert, Versandkosten für kleine Bestellungen: 2,40 EUR, darüber 4,40 EUR
* ansässig in 90489 Nürnberg

=== H-Tronic ===
Homepage: http://www.h-tronic.eu/index.php

* Online-Shop einer Entwicklungsfirma, in dem neben Baugruppen und Geräten auch einige Bauelemente und Elektronikzubehör angeboten werden
* kleines Angebot

=== Hallmanns Elektronik ===
Homepage: http://www.hallmanns.com 
Adresse: Bruno Hallmanns, Weierstraße 41, 52349 Düren

* Elektronikhändler mit Ladenlokal und Versand
* Ladentypisches Sortiment (Bauteile, Geräte, PC, Funk, Hifi...)

=== Hari Seligenstadt ===
Homepage: http://www.hari-ham.com

* Bausätze, Ringkerne, Geräte für Amateurfunk

=== HBE - Heinz Büchner Elektronik, Messtechnik, med. Elektronik e.K. ===
Homepage: http://www.hbe-shop.de/katalog/

* Bezeichnet sich als ''[[#Farnell|Farnell]] Fachhändler'', bei dem nichtgewerbliche Kunden aus dem Farnell-Sortiment bestellen können.
* Preise für Farnell-Produkte normalerweise Farnell Netto-Preis + MwSt.
* Mindestbestellwert 25,- € (netto), Mindermengenzuschlag 5,- € (Stand 06/2010)
* Versandkosten 4,75 € (netto), ab 75,- € (netto) versandkostenfrei (Stand 06/2010)

=== Heho-Elektronik ===
Homepage: http://www.heho-elektronik.de
* Halbleiter / Bauteile, Sortimente, Handy - Akkus, VELLEMAN - Bausätze
* Aktuelles Angebot, Ladegeräte / Akkuladegeräte, Blei - Akkus
* Spannungswandler, Audio / Video / USB - Kabel, Netzwerk - Kabel
* 1-2 Arbeitstage für Waren ab Lager
* Porto + Verpackung pauschal Euro 4,50
* Mindestbestellwert von € 10,00

=== Hinkel ===
Homepage: http://www.hinkel-elektronik.de

* Von der Webseite "Unser Angebot richtet sich an Schulen, Behörden, Handel, Handwerk und Industrie."
* Batterien
* Knopfzellen, spezielle KZH, die man sonst lang sucht, findet man hier
* Mindestbestellwert von 20€
* Standardversand innerhalb Deutschlands 5,80€

=== HN Electronic Components GmbH & Co. KG / Netzteilshop ===
Homepage gewerbliche Kunden: http://www.hn-electronic.de/
* Netzteile aller Art
* Es gibt keinen Onlineshop mehr, wahrscheinlich werden Endkunden nicht beliefert
** Homepage Endkunden: http://www.netzteilshop.com/hnshop.html
** Lieferung an Endkunden nur per UPS Nachnahme.
** Mindestbestellmenge für Endkunden 25 €

=== Home-Electronic24 ===
Homepage: http://www.home-electronic24.de/

=== HW-Electronics ===
Homepage: http://www.hw-electronics.de 
Homepage EU: http://hw-electronics.eu/

* Tauch- und Sprühätzanlagen
* Entwicklungsgeräte
* Belichtungsgeräte, Materialsätze zum Selbstbau von Belichtungsgeräten

=== ID-Elektronik ===
Homepage: http://www.id-elektronik.de

* Amateurfunk-Baugruppen

=== IT-WNS ===
Homepage: http://www.it-wns.de

* "Bauteile, Platinen, Bausätze" insbesondere mit ATMEGA und ENC28J60
* Bausätze zu Projekten aus dem Forum, z. B. USBprog, ChipBasic, Mikro-Webserver, Transistortester u.v.a.m.
* Atmega32/644 Experimentiersystem als Bausatz mit vielen Zusatzmodul-Bausätzen
* SD-Slots, RFID, Bluetooth-Module, AVR Mikrocontroller uvam.
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage (Kontaktformular) beschafft werden
* günstige Preise und Versandkosten ab 1,90EUR, kein Mindestbestellwert
* schneller Versand, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung

=== Kabelscheune ===
Homepage: http://www.kabelscheune.de

* "Direktversand von Elektromaterial und Multimediaprodukten"

=== Kelemen ===
Homepage: http://www.kelemenantennen.de/Kelemen-Shop/

* Messgeräte, Antennen und Zubehör für den Amateurfunk

=== Kessler ===
Homepage: http://www.kessler-electronic.de

* im Preis-Leistungsverhältnis mit Reichelt zu vergleichen (sprich: günstig)
* Sortiment kleiner als Reichelt und mit gewissen Abweichungen (z. B. andere FPGA und RAMs)
* oft lange Lieferzeiten
* Versandkosten innerhalb Deutschlands 4€ (Brief), 5€ (DHL-Paket), 10€ (DHL-Express-Paket)

=== Klein-Electronic ===
Homepage: http://www.klein-electronic.de

* Baugruppen zur Video- und 2,4GHz-Sendetechnik

=== Konni-Antennen ===
Homepage: http://www.konni-antennen.de

* Antennen für TV, Amateurfunk
* Zubehör, Einzelteile
* sehr netter kompetenter Service

=== Köditz Nachrichtentechnik ===
Homepage: http://www.koeditz-nachrichtentechnik.de

* Baugruppen und Bauteile für Amateurfunk und TV-Satellitenempfang

=== Kuhne DB6NT ===
Homepage: http://www.kuhne-electronic.de

* Baugruppen und Bausätze für Mikrowellenamateure

=== LEDSEE Electronics ===
Homepage: http://www.ledsee.com

* LEDs, LCDs, diverses
* Lieferung direkt aus China, daher sehr günstig und lange Lieferzeiten

=== LED Microtechnics LTD ===
Homepage: http://www.ledmeile.de

* "LED Shop und Lampentechnik"

=== LED-Tech LED-Shop ===
Homepage: http://www.led-tech.de

* viele verschiedene LEDs zu sehr guten (meist den günstigsten) Preisen
* vor allem auf High-Power-LEDs spezialisiert
* viele verschiedene Treiber für High-Power-LEDs
* kostenloser Versand
* haben ein eigenes, sehr umfangreiches Forum

=== Lieske Elektronik ===
Homepage: http://www.lieske-elektronik.de

* liefert nur an Geschäftskunden

=== Lüdeke Elektronic ===
Homepage: http://www.luedeke-elektronic.de/

* großes Sortiment, bietet unter anderem auch viele selbst entwickelte Bausätze an

=== LUMITRONIX LEDs-Shop ===
Homepage: http://www.leds.de

* alles rund um LEDs (auch Zubehör und Lektüre)
* neben Standard-LEDs auch SMD- und SuperFlux-LEDs

=== Marsch Elektronik, M. Schlimper ===
Homepage: http://www.marsch-elektronik.de

* Online Shop für aktive und passive Bauelemente
* Versandkosten ab Euro 1,60
* kein Mindestbestellwert
* bietet auch Einsteigersortimente und Widerstandsortimente (auch SMD)
* liefert nur innerhalb Deutschlands
* nicht gelistete Artikel können angefragt werden und werden meist auch beschafft

=== Mauritz Communication & Electronics ===
Homepage: http://www.mauritz-shop.eu

* Online Shop für HF-Stecker und Kabel
* bietet HF-Stecker/Buchsen und Koaxkabel an
* große Auswahl, auch exotische Teile
* Kabelkonfektionierung nach Wunsch
* vernünftige Preise
* liefert nach Rücksprache auch weltweit
* Keine Mindestbestellwert, aber 5 € Aufschlag unter 15 €
* Versand bis 40 kg pauschal 5,95 € per GLS innerhalb DE
* schneller Versand
* Paypal oder Vorkasse

=== Mein-Daarle ===
Homepage: http://www.mein-st-arnual.de/shop/saarbruecken/artikellisteL.html

* Teileliste eines "Händlers aus Saarbrücken" (wahrscheinl.: Frank Skowronek ESS Elektronik Service), "bis sein Onlineshop ans Netz gehen kann"
* derzeit (4/2011) kein Onlineshop, Kontakt über Formular

=== Micromaus ===
Homepage: http://www.micromaus.de

* Sensoren
* Mikrokontroller
* kein Mindestbestellwert
* 22.7.2012: Totalausverkauf wegen Geschäftsaufgabe, 10% auf alle Artikel

=== Microcontroller-Starterkits ===
Homepage: http://www.microcontroller-starterkits.de

* 22.7.2012: Seite nicht erreichbar
* Bauteile: CAN, Ethernet, Mikrokontroller AVR und ARM, Linearregler 1,8V 3,3V 5V in SOT223
* Leerplatinen, Bausätze
* günstig
* Abholung in Hattingen möglich
* Versandkosten innerhalb Deutschlands ab 2,50€
* keine Kreditkartenzahlung möglich

=== Mikrocontroller.net ===
Homepage: http://shop.mikrocontroller.net

* Starterkits, Development Boards und Zubehör für AVR, AVR32, ARM und MSP430

=== Mira Nürnberg ===
Homepage: http://www.mira-electronic.de

* SMD-Bauteile, SMD-Sortimentboxen
* Verkauf und Preisangaben nur für Gewerbetreibende



=== Mouser ===
Homepage: http://de.mouser.com

* Liefert an Privat
* Zügige Lieferung mit FedEx aus den USA
* Keine Halbleiter von Linear, National und Analog

=== MS-Elektronik ===
Homepage: http://www.ms-elektronik.info

* Liefert an Privat
* Zügige Lieferung
* Gute Qualität
* Viel in Richtung Audio
* Große Auswahl an Elkos -> kleine Preise
* kein allzu großes Sortiment

=== Mütron ===
Homepage: http://www.muetronshop.de

* Keine Privatkunden

=== myAVR Shop ===
Hompage http://shop.myavr.de

* Kleine Auswahl, aber die angebotene Ware ist sehr preiswert (meist preiswerter als bei Reichelt)
* Zügige Lieferung (1-2 Werktage)
* Diverse Zahlungsmöglichkeiten: Rechnung, Vorkasse, Lastschrift, Kreditkarte, PayPal
* Kein Mindestbestellwert
* Sehr günstige Versandkosten ab 1,95 Eur
* Mengenrabatt ab 10 gleichen Artikeln

=== Neuhold-Elektronik ===
Homepage: http://www.neuhold-elektronik.at 
Shop: http://www.neuhold-elektronik.at/catshop/default.php?language=de

* preiswerte Schnäppchen
* regelmäßig aktualisierte Angebotsliste herunterladbar
* Ab 60,- EUR versandkostenfrei in Österreich

=== Octamex ===
Homepage: http://www.octamex.de

* Leiterplattenchemie (Entwickler, Ätzmittel, CRC-Sprays)
* Chemisch Zinn
* Lötstopp-Laminat, Tentingresist, Bestückungsdruck
* Bungard Basismaterial in 0,5mm 1,0mm 1,5mm Dicke und 18µm, 35µm, 70µm Kupfer
* Bungard Alucorex für 19" Frontplatten
* Bungard Cotherm, Alukernbasismaterial
* Funkmodule 434MHz, 868MHz, 2.4GHz
* Löttechnik und Zubehör
* Gehäuse aller Art
* Messgeräte und Labornetzteile
* aktive, passive u. mechanische Bauelemente (Widerstände, Kondensatoren, Transistoren, Logik-ICs etc.)
* kein Mindestbestellwert
* Lieferung auch ins Ausland
* Versandkosten ab 4,50EUR
* Liefert nur gegen Vorkasse, ausser für Bestandskunden, die schon häufig bestellt haben
* Zahlung mit EC-Pay oder Kreditkarte nur gegen Aufschlag (bis zu 5%)

=== Online Batterien ===
Homepage: http://www.online-batterien.de

* Allerlei günstige Batterien & Akkus vieler Marken
* z. B. '''40 Stk.''' DURACELL PLUS LR6 AA 11,59€ (Jan 2010)
* Beleuchtungsartikel
* USV
* Versand ab 3,90€

=== Oppermann ===
Homepage: http://www.oppermann-electronic.de

* Restposten, auch HF Bauteile
* auch Privatkunden
* Lieferung nach üblicher Zeit

=== PCB-Soldering ===

Homepage, Online-Shop: http://www.pcb-soldering.co.uk
eBay: http://www.allendale-stores.co.uk
Firmen-Homepage: http://www.allendale-elec.co.uk

* [http://www.aoyue.com/en/products.asp Aoyue] Lötstationen und preiswertes Zubehör (Lötspitzen) für diese. Bei Aoyue-Zubehör bessere Preise (Stand 10/2008) als [[#WilTec_Wildanger_Technik_GmbH|WilTec]]
* Schnelle Lieferung
* Dank [http://www.zoll.de/b0_zoll_und_steuern/a0_zoelle/a1_grundlage_zollrecht/b0_zollgebiet/index.html EU Binnenmarkt] nur britische Mehrwertsteuer (VAT), kein Zoll, keine [http://www.zoll.de/b0_zoll_und_steuern/a3_einfuhrumsatzsteuer/index.html Einfuhrumsatzsteuer] fällig.
* Zwei von drei E-Mails wurden nicht beantwortet
* Versandart wurde eigenmächtig von "Standard" auf teureres "Signed for" (Einschreiben) geändert

=== Pollin Electronic ===
Homepage: http://www.pollin.de

* Günstige Restposten aller Art (z. B. "250 g verschiedene ICs" u.dgl.)
* Produktkategorien:
** Computer und Zubehör
** Telefone und Zubehör
** Antennentechnik
** HiFi/Car-HiFi/Video/TV
** Stromversorgung
** Lichttechnik
** Messtechnik / Uhren
** Haustechnik
** Werkstatt
** Bauelemente
** KFZ- und Zweirad
** Motoren
** Bausätze
** Fundgrube
* Produkte teils schnell ausverkauft
* Qualität schwankend. Man kann gute Schnäppchen machen aber auch reinfallen. Umtausch ist dann aber problemlos.
* Es wird öfters von sorgloser Verpackung berichtet, trotz Verpackungspauschale von 0,85 % des Warenwerts (empfindliche und schwere Produkte besser nicht zusammen bestellen). Reklamationen bei Beschädigungen werden freundlich behandelt.
* Lieferzeit i.d.r. 2-3 Werktage / knappe Woche bei neuer Sonderliste
* Ladengeschäft in 85104 Pförring
* Versandkosten innerhalb Deutschlands 4,50 € (ab 150€ versandkostenfrei); dazu 0,85 % Verpackungspauschale
* Zahlung per Nachnahme (+2,50 €) oder Bankeinzug (keine Kreditkarte, keine Überweisung)

=== proma / Isel ===
Homepage: http://www.isel.com/en/proma_systro.php

The proMa systro GmbH has completed its business transactions since the 20th February 2009.
Nachfolger: http://idimod.iselshop.de/
<s>
* fotobeschichtete Leiterplatten Platinenfrästechnik
* Chemikalien für die Platinenherstellung: Ätzmittel, Flussmittel für Lötanlagen, etc.
* Profilgehäuse, u.a. von Conrad und Reichelt vertrieben
</s>

=== QRP-project ===
Homepage: http://www.qrpshop.de/

* Bausätze vor allem einfache Kurzwellen-Funkgeräte

=== Reichelt ===
Homepage: http://www.reichelt.de

* relativ große Auswahl, aber nicht viele "brandaktuelle" Bauteile
* wenn man höflich fragt, liefern sie ganz selten auch Bauteile, die nicht im Katalog stehen zu "normalen" Preisen (vorausgesetzt der Hersteller ist im Sortiment), z. B. Xilinx XC2S50, aber meist erhält man die Antwort, dass der Artikel nicht im Sortiment ist, obwohl auf der Homepage unter Service extra ein Punkt angeführt ist: "Ich benötige einen Artikel, der nicht im Programm ist"
* reagiert aber teilweise auch auf Anregungen, neue Produkte in das Angebot aufzunehmen; siehe dazu auch den Artikel [[Reichelt-Wishlist]]
* liefert schnell und vollständig; wenn etwas ausnahmsweise nicht verfügbar ist, dann liefern sie es auf eigene Kosten nach, wenn der Artikel in absehbarer Zeit wieder vorrätig ist (selbst wenn er nur 0,20€ wert ist).
* lässt einen dennoch manchmal warten, wenn ein Artikel nicht lieferbar ist! Daher bei der Bestellung immer darauf hinweisen, dass man auch eine Teillieferung akzeptiert. (Laut Auskunft dauert das länger, besser nach der Inet-Bestellung anrufen und nicht lieferbare Teile aus der Bestellung streichen lassen)
* Lieferzeiten normalerweise 2 - 4 Arbeitstage
* niedrige Preise (aber unbedingt Qualität des Artikel checken)
* Versandkosten 5,60€ (Deutschland); 10€ Österreich; Schweiz 16€; EU 15 - 19€;
* 10€ Mindestbestellwert für alle Länder
* auch in die Schweiz sehr guter Service
* holt sich auch ohne Erlaubnis Bankauskünfte bei großen Bestellungen ein

=== RFW Elektronik ===
Homepage: http://www.rfw-elektronik.de

* HF Bauelemente

=== Ribu ===
Homepage: http://www.ribu.at

* Sehr guter Elektronikversand in Österreich mit zahlreichen Entwicklungsboards und zahlreichen Elektroniklösungen.
* Liefert sehr schnell und hat eine ausgezeichnete Beratung.
* Online-Shop ist sehr übersichtlich und einfach zu bedienen.
* Lieferstatusanzeige für alle Artikel. Bei Auslaufartikeln ist sogar die noch verfügbare Stückzahl sichbar.
* Günstige Sonderangebote
* innerhalb Österreichs 4,90€ Versandkosten, ab 80,- keine Versandkosten
* ausserhalb Österreichs 13€ Versandkosten, ab 225€ versandkostenfrei
* liefert auch an Privatkunden
* Mindestbestellwert innerhalb Österreichs 10€, ausserhalb 30€

=== Richardson Electronic ===
Homepage: http://www.richardsonrfpd.com/

* Hochfrequenz-Halbleiter, HF-Röhren,

=== Riedl Elektronik ===
Homepage: http://www.riedl-electronic.at

* großes Angebot v.a. ICs und Trafos
* recht günstig
* Rabatt für Schüler/Student
* Versand nach AT: 3,95€ bis 1kg, ab 100€ frei Haus
* Versand AT über 1kg sowie Ausland: Nach Aufwand (wird nicht direkt angezeigt)

=== RLX COMPONENTS s.r.o. ===
Homepage: http://www.rlx.sk

* Man spricht Deutsch
* Messgeräte, Mikrocontroller-Boards, Bauelemente

=== RM Computertechnik GmbH ===
Homepage: http://www.rm-computertechnik.de

* Kerngeschäft ist PC-Technik, aber auch großes Sortiment an Kabeln, Litzen und Steckverbindern
* handelt auch mit einigen Bauelementen, wie LED's

=== Robotikhardware===
Homepage: http://www.robotikhardware.de

* Microcontroller
* Entwicklungsboards
* Sensoren
* Robotik-Zubehör
* günstige Angebote für Hobbyelektroniker
* auch einzelne Platinen

=== Robotik-Teile.de===
Homepage: http://www.robotik-teile.de

* Große Auswahl an Elektronik Produkten
* Microcontroller, Sensoren, Zubehör, u.v.m.
* Versandkosten betragen immer 4,90 €
* Zahlbar ber PayPal, Sofortüberweisung, Vorkasse und Nachnahme

=== Benno Rößle Elektronik ===
Homepage: http://www.roessle-elektronik.de

* Masten, Antennen, Befestigungsmat.,Zubehör, Geräte, Anpassteile, HF-Stecker

=== RS Components ===
Homepage: http://de.rs-online.com

* lt. AGB nur an gewerbliche Abnehmer und an Studenten. Bei Internetbestellungen wird per Mail nach Belegen gefragt.
* gute Auswahl insbesondere an "mechanischen Bauteilen"
* gute Verfügbarkeit
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (GP)
* Preise wurden angepasst, gute Preis/Leistung
* Preis im Onlineshop sind ohne MwSt angegeben
* Bei Onlinekauf ist der Versand kostenfrei, ohne Mindesbestellwert.
* Notify-Me Service für Produktabkündigung
* Auch größere Stückzahlen über Allied möglich
* Relativ große Auswahl an Sortimenten (Widerstände, Kondensatoren), Einzelteile können teilweise nachgekauft werden
* Verfügbarkeitsanzeige im Internet ist ziemlich hilfreich
* Nützliche Tipps zum Thema RoHS
* Macht anscheinend Abfragen bei SCHUFA & Co. ohne Einverständnis oder Hinweis in den AGB.

=== Sander Elektronik ===
Homepage: http://www.sander-electronic.de

* beliefert auch Privatkunden, Bankeinzug möglich
* ähnlich Segor ein Berliner Versender
* Hier findet man manche [[MSP430]], die es sonst nicht in kleinen Stückzahlen gibt
* Herr Sander ist sehr kompetent und selbst Autor von Fachartikeln
* selbst abgekündigte Halbleiter können noch beschafft werden
* Bezahlung auch mit Kreditkarte möglich
* Versandkosten innerhalb Deutschlands ab 3,35€, innerhalb Europas ab 6€

=== Sasco Holz ===
Homepage: http://www.sasco.de

* Wie Spoerle eine Tochter von Arrow.
* Distributor für Analog Devices...
* Liefert wie Spoerle und Arrow in Deutschland nicht an Privatkunden.

=== Sat-Schneider ===
Homepage: http://www.sat-schneider.de
* Bauteile, Ersatzteile Online-Shop
* Baugruppen zum Empfang des Digitalen Kurzwellenrundfunks DRM

=== Satistronics ===
Homepage: http://www.satistronics.com

* typischer "China-Versender", mit allen Vor- und Nachteilen
* Lieferzeit bei Standardversand sehr lange (etwa 1 Monat nach D), aber schnellere Lieferung gegen Aufpreis möglich
* tritt auch bei eBay in Erscheinung ([http://stores.ebay.de/satistronicsstore eBay-Shop]), die Preise dort sind in der Regel aber etwas höher als im Online-Shop

=== Otto Schubert GmbH ===
Homepage: http://www.schubert-gehaeuse.de

* Kein Online-Shop. Bestellungen nur per Telefon, Fax oder E-Mail
* Weissblechgehäuse, Gerätegehäuse, wetterfeste Gehäuse
* Drehkondensatoren
* Sonderanfertigungen
* ansässig in 90574 Roßtal

=== Schramm-Software ===
Homepage: http://www.schramm-software.de/bausatz/
* Online-Shop, bietet Elektronik-Bausätze mit Mikrocontrollern
* Bausätze als Lehrmaterial geeignet, da ausführliches Begleitheft mitgeliefert wird (Aufbauanleitung, Schaltung, Controllerprogramm, Experimente...)
* bisher nur ein relativ kleines Sortiment, soll ergänzt werden
* Versandkosten innerhalb Deutschlands 2,50 €, innerhalb der EU 3,50 €

=== Schukat elektronic ===
Homepage: http://www.schukat.de

* liefert nicht an privaten Endverbraucher
* einfache und passiver Bauteile oft nur in großen Mindeststückzahlen
* ICs teilweise recht preiswert (vor allem bei mehr als 1 Stück, z. B. auch AVR)
* LCDs sehr preiswert und auch als Einzelstücke
* aktuelle Preise und Verfügbarkeit im Internet (aber nur nach Anmeldung -jetzt nicht mehr bei kleinen Stückzahlen), ebenso Bilder von Gehäusefootprints u.dgl.
* Abholung in Monheim am Rhein nach Vereinbarung möglich
* Versandkosten innerhalb Deutschlands ab 5€ (bis 10kg!)

=== Schuricht ===
Homepage: http://www.schuricht.de

* deutscher Ableger der Distrelec- (Elektronik) und Disdata-Gruppe (Computertechnik)
* Liefert auch an Privatkunden (getrennte AGBs für gewerbliche und Privatkunden, Lieferung an Privat per Nachnahme: Versandkosten ab 6,54€ plus 4,76€ Nachnahmegebühr).
** Online-Bestellung von Privatkunde scheiterte daran, dass die Onlineshop-Bestellformulare nur für gewerbliche Kunden ausgelegt sind und der Onlineshop Bestellungen ohne Firmenangaben nicht annimmt oder gar mit einer internen Fehlermeldung quittierte.
**Online Bestellung mit "Privat" als Firmenangabe funktionierte einwandfrei.
**Telefonische Bestellung von Privat funktioniert. Nette, freundliche Behandlung am Telefon, kein Callcenter. Versprochener Rückruf erfolgte mit gewünschten Informationen. Neben Nachnahme wurde für einen relativ teuren Artikel persönliche Abholung angeboten. Angegebene Lieferfrist wurde leicht unterschritten.
* Papierkatalog über 2000 Seiten, durchgehend farbig, nur für Geschäftskunden erhältlich.
* Ziemlich teuer

=== Schuro Elektronik GmbH ===
Homepage: http://www.schuro.de

* Elektronische Bauelemente und Bauteile für den Audio- und Lautsprecherbau (Kondensatoren, Spulen u.dgl.)
* kein Mindestbestellwert
* Versandkosten innerhalb Deutschlands gewichtsabhängig ab 5,75€

=== Segor-electronics ===
Homepage: http://www.segor.de

* Spezialist für Halbleiter, die ansonsten für nicht-gewerbliche Abnehmer nur schwer erhältlich sind (Preise dahingehend "angemessen")
* auch Privatkunden gerne gesehen
* Ladengeschäft in Berlin
* kein Mindestbestellwert bei Versand innerhalb der EU

=== SE Spezial-Electronic AG ===
Homepage: http://www.spezial.de

* Distributor
* Laut AGB auch Verkauf an Privat.
* Große Verpackungseinheiten/Mindestbestellmengen pro Bauteil
* Versandkosten pauschal 9,- € (Deutschland) (Stand 08/2008)

=== Shortec Electronics ===
Homepage: http://www.shortec.com

* Unabhängiger Distributor von elektronischen und elektromechanischen Bauelementen aller Hersteller.

=== Small Control Shop ===
Homepage: http://www.small-control.de

* "Bernd Walter Computer Technology"
* kleines Lieferprogramm aber ein paar interessante Produkte

=== SMG Diffusion - F1GE ===
Homepage: http://www.smgdiffusion.com
( Seite nur französisch )

* Videotechnik,
* 1,2 GHz / 2,4GHz Module
* Gebraucht-Messgeräte HP, Tek, Philips u.a.
* GHz-Halbleiter
* Koax-Adapter
* Antennen

=== Spoerle ===
Homepage: http://www.spoerle.de

* Früher eine Tochterfirma von Arror. Mittlerweile komplett in Arrow aufgegangen, Webseite leitet auf Arrow um.
* Aus dem Webshop: "Unser Angebot richtet sich nur an Kaufleute und nicht an Verbraucher."
* Wenn es wirklich über Arrow sein muss, dann kann man es als Privatperson bei Arrow Electronics North American Components http://www.arrownac.com/ versuchen, die sich normalerweise nicht weigern ihre Produkte zu verkaufen. Allerdings muss man mit großen Mindestmengen (z. B. BC547 in Schritten von 2000 Stück) und hohen Kosten rechnen.
:Zu den Kosten gehören zum Beispiel ein mehrfacher Mindermengenzuschlag (''$10 handling charge will be added to each line item less than $30''), eine satte ''handling and energy fee of $10.22'' (mehr als 10x zu hoch wie die vergleichbare Gebühr für amerikanische Besteller), hohe Versandkosten (ab $20 nach Deutschland). Dazu kommen die üblichen Kosten für den Import aus dem Ausland (Einfuhrumsatzsteuer, Kreditkartengebühr, ...)

=== SR-Systems ===
Homepage: http://www.sr-systems.de

* Baugruppen für Digital-TV, Sende- und Empfangstechnik
* DVB-S, DVB-T

=== Strixner&Holzinger ===
Homepage: http://www.sh-halbleiter.de

* Ladengeschäft in München
* Versand
* riesiges Angebot an Halbleiter, auch schwer beschaffbare
* Online-Shop

=== TAUTEC-ELECTRONICS ===
Homepage: http://www.tautec-electronics.de

* Online Shop für aktive elektronische Bauelemente
* günstige Preise (Vorsicht, Preisangaben enthalten keine Mehrwertsteuer) aber Mindestbestellwert 100 Euro
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, Car-HiFi und TV-Bereich

=== TCB-Versand ===
Homepage: http://www.tcb-versand.de

* insbesondere für Modellbauer ein sehr interresantes Sortiment
* Stecker,Kabel etc. recht günstig und kleine Mengen abnehmbar
* Lieferung normal zwischen 1 und 3 Tage
* leider nur Online-Shop

=== TecHome.de Online-Shop ===
Hompage: http://www.techome.de/index.html

=== Tec-Shop (Wolfgang Rompel Elektronik) ===
Homepage: http://www.tec-shop.de

* Kleines, aber ausgesuchtes Sortiment
* Interessantes Angebot an Sensoren

=== Technik-Welt / Industrieshop.at ===
Homepage: http://www.industrieshop.at

* Laut Homepage richtet man sich "an den industriellen Kunden". Laut AGB sieht man das jedoch nicht so eng, Zitat:
:: ''TW schließt online Verträge nur mit Kunden ab, die natürliche oder juristischen Personen sind, die ihren Wohnsitz oder Sitz in Österreich, einem Mitgliedsstaat der Europäischen Union (EU25) oder der Schweiz haben.''
* [[#Farnell|Farnell]] Teile
* In Österreich
* Schnelle Lieferung (2 Tage)

=== TIGAL KG ===
Homepage: http://www.tigal.com

* Boards und Tools für Embedded-Elektronik
* In Österreich
* Versandkosten ab € 7,00 in Österreich, ab € 10,00 nach Deutschland.
* Preisangaben ohne MWSt. Für Privatkunden kommen 20% österreichische Mehrwertsteuer hinzu.
* U.a. ZeroLogic Logik-Analysatoren.

=== TME (Transfer Multisort Elektronik) ===
Homepage: [http://www.tme.eu/de]

* Firmensitz in Łódź, Polen
* Zahlungsabwicklung über deutsches Konto oder PayPal
* Firmenvertretung in Leipzig, man spricht deutsch
* Versand mit UPS (etwa 8 Euro inkl. MwSt.); Trackingnummer wird sofort nach Kommissionierung zugesendet
* als Privatkunde: Mehrwertsteuer beachten (23%). Seit neuestem 17,6% "Strafaufschlag" auf Bruttopreis bei Privatbestellung. Effektiv ergibt dies ca. 45% (!) auf den Nettopreis. Zitat auf Nachfrage: "Bei Rechnungserstellung für Privatkunden wird der angezeigt Preis + 15% (Rabatt für Firmenkunden) + 23% poln. Mwst. ausgewiesen".
* sehr großes günstiges SMD Sortiment
* unmittelbar aktualisierter Lagerbestand, Mindestmengen und Vielfache beachten

=== Trade-Shop / AIR Electronics GmbH ===
Homepage: http://www.trade-shop.de

* Trotz knackiger Sprüche auf der englischen Version der Webseite ("Electronic Components Superstore") eher kleines Angebot elektronischer Bauteile
* 20 Euro Mindestbestellmenge (Stand Februar 2008)
* ab 6,90 Euro Versandkosten (Deutschland, bis 1kg) (Stand Februar 2008)

=== Trenkenchu & Stadler GbR ===
Homepage: http://www.ts-audio.de

* die meisten Artikel sind deutlich teurer als der Marktpreis, es sind jedoch auch Schnäppchen dabei, z.B. HDMI-Kabel

=== TV-Ersatzteile ===
Homepage: http://www.tversatzteile.de

* TV-, Audio-, Video-Ersatzteile, Aktive / Passive Bauteile
* Fernbedienungen Haushaltstechnik

=== UKW-Berichte ===
Homepage: http://www.ukw-berichte.de

* Antennen, Bauteile, Bausätze, Literatur für Amateurfunk
* ansässig in 91081 Baiersdorf

=== Voelkner ===
Homepage: Kein Link, entsprechend der Vorgabe des Betreibers der Voelkner Webseite im Impressum:
<blockquote>voelkner - direkt günstiger
 
wird produziert und betreut von 
Re-In Retail International GmbH 
... 
Eine Verlinkung auf die Website der Firma Re-In Retail International GmbH bedarf einer schriftlichen Genehmigung. </blockquote>

* Großer Teil des Conrad-Programms, identische Nummern, identische Aufkleber auf der Ware, Preise identisch oder nur ein paar Cent abweichend
* Versandkosten Deutschland: 4,95€; ab 25€ Warenwert und Sofortüberweisung.de versandkostenfrei / Versandkosten-Flatrate für 15€ pro Jahr
* Versandkosten EU: 9,95€
* Möglichkeit der Versandkostenflatrate (D): Einmalig 14,95€ / gültig für ein Jahr
* Legt jeder Bestellung gleich wieder einen Gutschein über 5€ bei MBW 25€ bei (Flat nur bei häufigen, kleinen Bestellungen sinnvoll); außerdem kommt etwa alle 2-3 Monate selbiger Gutschein + versandkostenfreie Lieferung per Mail, ebenfalls MBW 25€
* Verpackungsqualität wechselnd, mal brauchbar, mal eher Pollin-Niveau. Selbst kleine Bestellungen, die gefahrlos per Brief/Großbrief verschickt werden könnten werden in einem großen Paket versendet.

=== VOTI Webshop ===
Homepage: http://www.voti.nl/shop/catalog.html

* relativ kleines Lieferprogramm
* einige interessante Restposten (Surplus)

* Sitz in Amersfoort, Niederlande

=== Walter elektronik ===
Homepage: http://www.walter-elektronik.de

* Bauteile, Röhren

=== Waschbär Soft 2010 ===
Homepage: http://www.xn--waschbr-soft-2010-vqb.de

* Onlineversandhaus für Unterhaltungselektronik, "Haushaltselektronik", Computer und -zubehör
* keine elektronischen Bauteile

=== Watterott electronic GmbH===
Homepage: http://www.watterott.com

* Distributor für Arduino, BeagleBoard, FriendlyARM, Pololu, Seeed Studio, Solarbotics, SparkFun...vollständige [http://www.watterott.net/about#distri Liste hier]
* Entwicklungskits von Atmel, Luminary Micro, Microchip, Raisonance, TI
* Spezialbauteile von Davicom, FTDI, VLSI, WIZnet
* Bungard Basismaterial + Chemie
* kein Mindestbestellwert
* Zahlung: Vorkasse, Sofortüberweisung, PayPal, Nachnahme, Kreditkarte (Visa/Mastercard), Rechnung (nur gewerbliche Kunden)
* Versandkosten Dtl. (UPS):
** bis 25 EUR Warenwert: 3,50 Euro
** bis 50 EUR Warenwert: 2,90 Euro
** bis 150 EUR Warenwert: 2,00 Euro
** ab 150 EUR Warenwert: versandkostenfrei
* Versandkosten EU (UPS):
** bis 150 EUR Warenwert: 10,00 Euro
** bis 250 EUR Warenwert: 8,90 Euro
** bis 500 EUR Warenwert: 7,00 Euro
** ab 500 EUR Warenwert: versandkostenfrei
* Schneller, entgegenkommender Service

=== Westfalia ===
Homepage Deutschland: http://www.westfalia.de
Homepage Österreich: http://www.westfalia-versand.at

* Vor 85 Jahren in Hagen, Westfalen gegründet
* Elektronik nur ein kleiner Teil des Angebotes. Eher insgesamt Haushalts-, Werkstätten-, Agrar- und Gartenbedarf
* Elektroniksortiment stark schwankend. Momentan (Juni 2008) wenig Auswahl.
* Mindestbestellwert 18 €, bei Neukundenbestellungen mit Prämienanforderungen (wenig wertiges Geschenk) sogar 50 €.
* 4,95€ Versandkosten, ab 150€ Bestellwert versandkostenfrei
* Transportversicherung wird zusätzlich mit einem Zuschlag von 0,8% des Warenwertes berechnet.
* Einmalige Bestellung führte zu jahrelanger Zusendung von Werbung für Westfalia-Angeboten mit Gewinnspielen (Glücksnummern, Rubbellose, Glücksschlüssel, etc.)
* Verpackung ähnlich "sorgfältig" wie bei [[#Pollin_Electronic|Pollin Electronic]]. Übergroße Kartons, wenig Verpackungsmaterial, schweres Teil (Labornetzgerät) flog lose im Karton herum und zertrümmerte andere Ware.

=== WilTec Wildanger Technik GmbH ===
Homepage: http://shop.wiltec.info

* Aoyue Lötgeräte (Heißluft, Löten, Entlöten), Netzteile, Werkzeuge
* Aoyue Zubehör (Lötspitzen, Heißluftdüsen), Ersatzteile
* Andere, nicht Elektronik-Angebote, wie KFZ-Tuningteile
* Versand. Bei Voranmeldung auch Lagerverkauf.

=== Wüstens frag-jan-zuerst ===
Homepage: http://www.die-wuestens.de/dindex.htm

* Röhrentechnik
* Hochspannungs-Spezialteile

=== WIMO ===
Homepage: http://www.wimo.de

* Große Auswahl an Amateurfunktechnik

=== Zech DG0VE ===
Homepage: http://www.dg0ve.de

* Baugruppen für Amateurfunk

=== Diverse ===
* http://www.chip-flip.com - Europäisches Bauelementesuchsystem, franchised Lieferantensuche, Datenblätter und viele nützliche Informationen
* http://www.ecomponents-store.com/ Elektronische Bauelemente kaufen - Hier finden Sie eine große Auswahl an elektronischen und elektromechanischen Bauelementen von über 40 Herstellern.
* http://www.franchised-distributors.eu/ - Finden Sie Vertragsdistributoren von über 800 Halbleiterherstellern für elektronische und elektromechanische Bauelemente.

TODO: elektronik-fundgrube

==Ebay-Shops==

===Ego-China===
http://stores.ebay.de/Ego-China-Electronics TFTs und LCDs Versand aus China (2-3 Wochen)

===Sure-Electronics===
http://stores.ebay.de/Sure-Electronics Highpower LEDs und Verstärker 
Hat auch einen eigenen Shop: http://www.sureelectronics.net/ 
Versand aus China

===Ether-Deal===
http://stores.ebay.de/ether-deal Unter sonstiges viele versch. Elektronik-teile Versand aus China

===NooElec===
http://stores.ebay.de/NooElec USB-AVR Boards (mega32u2) und rgbled-matrizen Versand aus Kanada

==Messgeräte ==
=== Neue Messgeräte ===

Viele der oben genannten Elektronikversender verkaufen auch Messgeräte. Darüber hinaus gibt es diverse Versender, die sich hauptsächlich oder ausschließlich auf Messgeräte spezialisiert haben. Allerdings verkaufen viele davon nicht an Privat.

==== CalPlus GmbH ====
Homepage: http://www.calplus.de 
Shop: http://www.scopeshop.de

==== Cosinus ComputerMesstechnik ====
Homepage: http://www.cosinus.de

* Nicht an Privat

==== dataTec ====
Homepage: http://www.datatec.de

* Große Auswahl
* <s>(Nicht an Privat)</s> Bestellung von Privat problemlos möglich, Privatpersonen werden laut ABG per Vorkasse beliefert
* Studenten bekommen Rabatt, je nach dem, was bestellt wird
* Umständlicher Bestellvorgang, seitens DataTec teilweise auf dem Postweg -> Es dauert teil sehr lange bis die Ware ankommt
* Sehr freundlicher und kompetenter Service, per eMail als auch telefonisch

==== Donald4646 ====
Homepage: http://www.donald4646.co.uk

* In Schottland
* Als eBay-Shop gestartet
* Einfache, No-Name und Billigmarken (z. B. Oszilloskope)

==== Elektronik-Kontor Messtechnik GmbH ====
Homepage: http://www.ekomess.de

==== Meilhaus Electronic GmbH ====
Homepage: http://www.meilhaus.de

* Diverse Markenhersteller
* Eigenmarken

==== PinSonne-Elektronik ====
Homepage: http://www.pinsonne-elektronik.de

* Onlineshop
* Sehr kleines Sortiment
* UNI-T, RIGOL und andere asiatische Firmen

==== PK elektronik Poppe GmbH ====
Homepage: http://www.pk-elektronik.de

* U.a. Fluke Distributor.

====Präzitronic Hennig / Messgeräte Chemnitz====
Homepage: http://www.messgeraete-chemnitz.de

* Owon
* Selbst übersetzte deutsche Owon-Handbücher
* Fluke
* Zusätzlich kleines Angebot an Gebrauchtgeräten

==== ScopeShop Hamburg ====

* Von CalPlus übernommen, siehe [[#CalPlus_GmbH|CalPlus]]

==== SI Scientific Instruments GmbH ====
Homepage: http://www.si-scientific.de (Onlineshop) 
Homepage: http://www.si-gmbh.de (komplettes Programm)

* Onlineshop auf si-scientific.de
* Akzeptiert PayPal

==== SKY Messtechnik GmbH ====
Homepage: http://www.sky-messtechnik.de

* Kein Onlineshop (E-Mail oder Telefon)

==== TESTEC ====
Homepage: http://www.testec.info

* Tastköpfe-Hersteller
* Hameg Vertriebspartner
* B+K Precision Generalimporteur

==== Zeitech ====
Homepage: http://zeitech.eu/shop/

* Diverses (Rigol, Owon, etc.)

=== Gebrauchte Messgeräte ===

Dieser Abschnitt enthält Anbieter bei denen gebrauchte Messgeräte erhältlich sind.

==== Astro Electronic ====
Homepage: http://www.astro-electronic.de

==== eumex GmbH ====
Homepage: http://www.eumes.com/pub/de/

* Gebrauchte Messgeräte

==== HTB-Elektronik ====
Homepage: http://www.htb-elektronik.com

* Gebrauchte Messgeräte

==== IX Instrumex ====
Homepage: http://www.instrumex.de/index.cgi?User:LANGUAGE=de

* Gebrauchte Messgeräte

==== Christoph Lüders MessTechnik ====
Homepage: http://www.CLMT.de 
Online-Shop: http://www.shop-016.de/shop-CLMT.html 
eBay: http://myworld.ebay.de/c_h_r/

* Hat 2010 die Restbestände von Förtig übernommen

==== mbmt Messtechnik ====
Homepage: http://www.mbmt.com

* Gebrauchte Messgeräte
* Verkauf nur an Gewerbetreibende

==== Rosenkranz Elektronik ====
Homepage: http://www.rosenkranz-elektronik.de 
eBay Shop: http://stores.ebay.de/Rosenkranz-Elektronik-GmbH-Shop

* Gebrauchte Messgeräte
* Auch auf eBay zu finden

==== Helmut-Singer-Elektronik ====
Homepage: http://www.helmut-singer.de

* Gebrauchte Messgeräte
* Verkauf auch an Privat
* An den meisten Samstagen im Jahr auch Lagerverkauf, sonst Versand

==== Sphere ====
Homepage: http://www.sphere.bc.ca 
Messgeräte und Ersatzteile: http://www.sphere.bc.ca/test/index.html

* Gebrauchte Messgeräte
* Ersatzteile
** Besonders bekannt für Tektronix-Ersatzteile

==== Tektronix TekSelect ====
Homepage: http://www.tek.com/Measurement/tekselect/

* Tektronix verkauft selber gebrauchte und überarbeitete Tektronix-Messgeräte unter dem Label ''TekSelect''.
* Original Tektronix-Garantie
* Der Bestellvorgang nervt, man muss Kontaktaufnahme durch einen "Representative" erbeten.

== Siehe auch ==
* [[Platinenhersteller]]
* [[Lokale Elektroniklieferanten]]
* [[Eisenwarenversender]]

== Links ==

* http://www.xs4all.nl/~ganswijk/chipdir/ Suche nach integrierten Schaltkreisen
* http://www.alldatasheet.com Datenblätter

[[Kategorie:Lieferanten]]

STM32

2012-08-22T17:39:45Z

Mthomas: /* Installation für STM32 (Windows) */

STM32 ist ein Mikrocontroller-Familie von [http://www.st.com/mcu/inchtml-pages-stm32.html ST] mit einer 32-Bit [http://www.arm.com/products/processors/cortex-m/index.php ARM Cortex-M3/M4] CPU. Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt und löst damit die bisherigen ARM7-basierten Controller weitestgehend ab. Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrößen und -formen. Durch die geringe Chipfläche des Cores ist es ST möglich, eine 32 Bit-CPU für weniger als 1 € anzubieten.

[[Bild:stm32F103xc.png|thumb|right|340px|Blockdiagramm STM32F103xC/D/E]]

== STM32-Familien ==

Bisher gibt es sieben STM32-Familien:
* [http://www.st.com/internet/mcu/subclass/1588.jsp STM32F0]
** Cortex M0
** µC zum Einstieg
* [http://www.st.com/internet/mcu/subclass/1169.jsp STM32F1]
** Cortex M3
*** Connectivity line
*** Performance line
*** USB Access line
*** Access Line
*** Value line
* [http://www.st.com/internet/mcu/product/250173.jsp STM32F2]
** Cortex M3
** Wie die STM32F1 Serie, jedoch 120MHz, Camera-Interface, 32-Bit Timer, Crypto-Engine...
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3]
** ARM® Cortex™-M4-based STM32 F3, 72MHz
** DSP instructions and the floating point unit
** Fast 12-bit 5 MSPS and precise 16-bit sigma-delta ADCs
* [http://www.st.com/internet/mcu/subclass/1521.jsp STM32F4]
** Cortex M4
** ARM® Cortex™-M4-based STM32 F4, 168MHz
** DSP instructions and the floating point unit
* [http://www.st.com/mcu/inchtml-pages-stm32l.html STM32L]
** Cortex M3
** Low Power
** mit LCD Treiber
* [http://www.st.com/mcu/inchtml-pages-stm32w.html STM32W]
** Cortex M3
** RF-MCU
[http://www.st.com/internet/mcu/class/1734.jsp Hier eine Übersicht zum Auswählen eines STM32Fxxx]

'''Features'''
* Cortex-M3 bzw. Cortex-M4 Kern in der STM32F4xx Serie
* 16KB ... 1MB [[Flash-ROM]]
* 4KB ... 192KB [[Speicher#SRAM|SRAM]]
* 4KB [[Speicher#EEPROM|EEPROM]] (STM32L)
* 512 one-time programmable Bytes(STM32F2/4)
* [[IC-Gehäuseformen | Gehäuse]] 36 ... 176 Pins als QFN, LQFP und BGA
* Derzeit sind über '''250''' STM32 Derivate/Varianten verfügbar
* Bis 72MHz CPU-Takt, bis 120MHz beim STM32F2xx, bis 168 MHz beim STM32F4xx, wobei eine spezielle prefetch-hardware bis 120/168 MHz eine Geschwindigkeit erzielen soll, die 0 Wait-States entspricht. Der CPU-Takt wird über einen Multiplikator aus dem internen RC-Takt oder einem externen Quarz-Takt abgeleitet.
* Externes Businterface (nur bei Gehäusen ab 100 Pin und nur bei STM32F4, STM32F2 und STM32F1 Performance line)
* LCD Treiber für 8x40 Punkte (nicht beim STM32F2xx)
* Spannungsbereich 1,65 ... 3,6V, nur eine Betriebsspannung nötig
* Temperaturbereich bis 125 °C
* Bis zu 140 IOs, viele davon [[Pegelwandler|5V-tolerant]]
* Interner, kalibrierter RC-Oszillator mit 8MHz (16MHz bei STM32F2xx)
* Externer Quarz
* Real Time Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 16 [[Timer]], je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer (bei STM32F103xF/G)
* Systick Counter
* Bis zu 3 12-Bit [[AD-Wandler]] mit insgesamt 24 AD-Eingängen, integrierter [[Temperatursensor]], Referenzspannung Vrefint und VBatt Spannungsmessung (STM32F4xx)
* Bis zu 2 12-Bit [[DA-Wandler]]
* Bis zu 2 [[DMA]] Controller mit bis zu 12 Kanälen (16 beim STM32F2xx)
* Bis zu 2x [[I2C|I²C]]
* Bis zu 5x [[UART|USART]] mit LIN, IrDA und Modem Control (6 beim STM32F2xx)
* Bis zu 3x [[SPI]]
* Bis zu 2x [[I2S|I²S]]
* Bis zu 2x [[CAN]]
* Unique device ID register (96 Bits)
* RNG - Random Number Genrator (STM32F2xx)
* Cryptographic Processor (CRYP) (STM32F2xx)
* Hash Processor (HASH) (STM32F2xx)
* Kamera-Interface (DCMI) (STM32F2xx)
* [[USB]] 2.0 Full Speed / OTG
* [[USB]] 2.0 Hi Speed OTG mit extra PHY-Chip (STM32F2xx)
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich [[Ultra low power|Strom sparen]] lässt
* [[JTAG]] und SWD (Serial Wire Debug) Interface
* Bis zu 6 Hardware-Breakpoints für Debuggen
* und vieles mehr . . .

== Struktur der Dokumentation: ==

Als Beispiel der Dokumentation soll stellvertretend der [http://www.st.com/mcu/devicedocs-STM32F103RC-110.html STM32F103RC] genannt werden. Die Seite von ST beinhaltet alle nötigen Informationen passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00191185.pdf Datasheet STM32F103xC/D/E]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf Reference Manual (RM0008)]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/PROGRAMMING_MANUAL/CD00228163.pdf Cortex-M3 Programming Manual]
* [http://www.st.com/stonline/products/literature/pm/13259.pdf Flash Programming Reference]

Im Datasheet sind die speziellen Eigenschaften einer bestimmten Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für eine STM32-Familie. Details zum Prozessorkern selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich die Flash Programming Reference für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates. Hinzu kommen optionale Dokumente von ARM, die den [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337-/ Cortex-M3 Kern] / [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0439c/index.html Cortex-M4 Kern] beschreiben. Hier gibt es den Opcode wenn man ihn in [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0403-/ Assembler] programmieren möchte. Zusätzlich sollten auch die [http://www.st.com/stonline/products/literature/es/14732.pdf Errata Sheets] beachtet werden. Empfohlen sei auch die Appnote "[http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/APPLICATION_NOTE/CD00164185.pdf STM32F10xxx hardware development: getting started]".

== ‎STM32F10x Standard Peripherals Library ==

ST bietet eine umfangreiche Firmwarebibliothek, eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST (gibt es beispielsweise auf den Cortex-M3 Controllern von TI auch, ist teilweise in einem separaten ROM untergebracht). Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern. Diese Library und ihre Dokumentation setzen das grundlegende Verständnis der Funktion des jeweiligen Peripheriemoduls voraus, wie es die o.A. Referenz und diverse Appnotes vermitteln. Diese FW-Lib (Download von ST) ist ein MUSS für jeden, denn darin sind auch jede Menge Beispiele für alle Peripheriemodule.

Details siehe: [[‎STM32F10x Standard Peripherals Library]].

Mit [http://www.libopencm3.org/wiki/Main_Page libopencm3] ist derzeit auch eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library in Entwicklung, die zukünftig auch Cortex-M3 Controller von anderen Herstellern unterstützen soll.

== CMSIS ==

Parallel zur Firmware-Library (FW-Lib) gibt es für die "Selbermacher" die CMSIS (ARM® '''C'''ortex™ '''M'''icrocontroller '''S'''oftware '''I'''nterface '''S'''tandard), die grundsätzlich nur den herstellerübergreifenden ARM-Core abdeckt. Hierzu gehört bei den Cortex-M4-Cores auch die DSP und Floating-Point Funktionalität. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, den Sys-Tick-Counter, sowie eine SystemInit-Funktion, welche sich um die PLL kümmert.

Im Rahmen des CMSIS-Standards ([http://www.onARM.com www.onARM.com]) wurden die Headerdateien standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Die CMSIS C-Dateien bzw. Header enthalten auch Anpassungen für die verschiedenen Compiler. Die Portierung eines Real-Time-Betriebsystems sollte unter Verwendung der CMSIS, für Chips der verschiedenen Hersteller, stark vereinfacht möglich sein (z.B. einheitliche Adressen für Core-Hardware/Sys-Tick-Counter).

Die CMSIS ist im Download der FW-Lib enthalten. Die Compiler-Hersteller liefern eine jeweils zur ihrer Tool-Version passende bzw. geprüfte FW-Lib (incl. CMSIS) aus. Diese Libs können, gegenüber den Downloads beim Chip-Hersteller, auch ältere Version beinhalten.

== Debug- und Trace-Interface (CoreSight™ Debug and Trace Technologie)==

Übersicht über beide Funktionalitäten und den Schnittstellen:
http://www.keil.com/support/man/docs/ulink2/ulink2_cs_core_sight.htm

Die Coresight-Debug-Architektur ermöglicht ein nicht-invasives Debugging, d.h. es können während des Betriebes (meistens) ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Debugger Funktionen ===

Der Debugger-Teil besitzt drei Funktionen:
* Run Control: z.B. Programm-Start, Stopp und Einzel-Schritte.
* (Program) Break Points: Ein Programm hält an, wenn der Programm Counter eine bestimmte Programm-Adresse erreicht.
** Beinhaltet keine Data Watch Funktionalität, welche im Trace-Teil (DWT) realisiert wird.
* Memory Access: Lesen und Schreiben von Speicheradressen.
** Diese Funktionalität beinhaltet keine direkte Flash-Programmierung. Der Programmiervorgang für einen Flash ist herstellerspezifisch und muss von dem verwendeten Debugger unterstützt werden.

=== Trace Funktionen ===
Die Trace-Funktionalität wird in drei Funktionen aufgeteilt:
* ETM (Embedded Trace Macrocell): Optional, nicht jede CPU besitzt diese Hardware (Kostenfaktor, Austattung).
* ITM (Instrumentation Trace Macrocell): Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht werden, sowie "printf-ähnlich" Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.
* DWT (Data Watchpoint & Trace Unit):
** Data Watch: 4 Access-Break-Points ( z.B. der Debugger bleibt stehen, wenn das Programm auf einen Speicher zugreift oder der Wert einer Variablen einen bestimmten Wert annimmt).
** Trace Unit: Programmverlauf (durch Lesen des Program Counters) und Interrupt Aufrufe verfolgen, sowie Zeitmessungen.

Einige der Trace-Funktionalitäten können über die JTAG-Schnittstelle angesprochen werden. Die schnelle Trace-Funktionalität (mit 4 bit Parallel-Port) steht nur mit der erweiterten DEBUG + ETM Schnittstelle zur Verfügung. Im Gegensatz zum Debugger-Teil (Run Control, Break Points und Memory Access) werden Trace-Funktionen nicht von allen Debuggern unterstützt. Debugger mit der vollen Trace-Funktionalität kosten deutlich mehr.

* Beispiele für Trace-Port-Aktivierungen für verschiedene Hersteller: http://www.keil.com/support/man/docs/jlink/jlink_capture_tracedata.htm

Die Aktivierung des parallelen Trace-Ports erfordert, je nach CPU Hersteller, zusätzliche Debugger-Makros für die Aktivierung und Port-Freischaltung. Zusätzlich sind die Schnittstellenauswahl und Einstellung (Frequenzen) im Entwicklungs-Tool (IDE) wichtig, um erfolgreich den Programm-Verlauf "tracen" zu können.

=== Debug und Trace-Schnittstellen ===
Als Debug Interface stehen zwei Varianten zur Auswahl:
* [[JTAG]]: Dafür sind mindestens 6 Steuerleitungen nötig.
* SWD (Serial Wire Debug): Hier mindestens 2 Steuerleitungen (3 mit SWO, zzgl GND und 3,3V). Die SWD Schnittstelle ist in der Regel schneller und kann auch Funktionen aus dem Trace-Teil beinhalten (z.B. ITM, dafür wird der SWO-Pin benötigt).

Standard-JTAG Steckerbelegungen:
http://www.keil.com/support/man/docs/ulink2/ulink2_hw_connectors.htm

=== Der 10polige JTAG-Stecker von mmvisual ===
mmvisual hat mit dieser Steckerbelegung die Standard JTAG Schnittstelle erweitert:

Ich habe diesen Part in den Artikel [http://www.mikrocontroller.net/articles/JTAG#Der_10-Polige_JTAG_Stecker_von_mmvisual JTAG] verschoben.
Hinzu gekommen ist die Adapterplatine 10-Polig auf Standard JTAG 20 Polig mit TTL/V24 Wandler. [http://www.mikrocontroller.net/articles/JTAG#Die_Adapterplatine Siehe hier.]

=== STM32 RS232 (CAN und USB) Programmiertool ===

Auch ohne JTAG lässt sich ein STM32 programmieren (Bootloader-Aktivierung). Dabei stehen, je nach CPU-Typ, verschiedene Möglichkeiten zur Verfügung:
* RS-232 (bisher alle STMs)
* USB (nur in bestimmten MCUs mit entsprechender Bootloader-Version und PIN-Anzahl, z.B. STM32F105/107)
* CAN (wie USB nur in bestimmten MCUs)

3 zusätzliche Verbindungen müssen auf dem Board gepatcht werden. Für einen Test geht es auch mit Tastern für RESET und BOOT0. 
RESET=RTS (L-aktiv) 
BOOT0=DTR (H-aktiv) 
BOOT1=LOW 

Details sind hier im Forum: [http://www.mikrocontroller.net/topic/141711 STM32 Programmiertool]

== Vorteile ==

'''Vorteile gegenüber ARM7:'''

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vektortabelle, keine Sprungliste wie bei ARM7. Durch Automatismen zwischen Core und NVIC (auto register save r0..r3, lr, sp, pc) bei Interrupt Entry wird eine deutlich schnellere Ausführungszeit bei Interrupts erreicht. Der Interrupt Code muss sich nicht mehr selbst um die Sicherung der o.g. Register kümmern und eine besondere Konfiguration der Handler im Compiler entfällt. Sind vor Beendigung einer ISR (d.h. Rücksprung zum User Code) weitere Interrupts pending, so werden diese ausgeführt, ohne dass eine komplette pop-push-sequenz der Register notwendig ist. Schön beschrieben ist es hier im [http://www.st.com/mcu/files/mcu/1221142709.pdf Insider's Guide] unter 2.4.5 / Seite 20.
* Thumb-2 Befehlssatz, deutlich schneller als Thumb-1 und ebenso kompakt
* Weniger Pins für Debugging benötigt durch SWD
* Mehr Hardware Breakpoints machen debuggen einfacher
* Software ist einfacher weil die Umschaltung zwischen ARM Mode und Thumb Mode wegfällt

'''Vorteile gegenüber LPC1700 und LPC1300:'''

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* FW-Lib für alle STM32 gleich, alle AppNotes/Demos beziehen sich auf diese eine FW-Lib was die Entwicklung der eigenen Applikation sehr beschleunigt.
* Genauerer und flexiblerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010) Allerdings gibts den LPC1100 mit Cortex-M0 schon ab 0,65 $!
'''Nachteil gegenüber LPC1700:'''
* STM32F1xx: nur 72 MHz statt 100 MHz (LPC1759: 120 MHz) Taktfrequenz; STM32F2xx hat diesen Nachteil nicht (ebenfalls 120MHz, STM32F4xx mit 168MHz) (Aber NXP hat schon 150MHz angekündigt)
* Der LPC1700 besitzt deutlich mehr Mechanismen, um die Auswirkung der Waitstates des Flash-ROMs auf Code- und Datenzugriffe zu reduzieren und das bedeutet mehr Performance bei gleicher Taktfrequenz. Beim STM32F2 entfällt dieser Nachteil wohl aufgrund des ART accelerators.
* Alle LPC1xxx haben 32 Bit Timer. Bei den STM32 haben das nur die STM32F2xx (2 Stück)
* I2S Einheit von ST hat keinen FIFO und im 24/32Bit Modus müssen 2x16Bit Halbwörter übertragen werden.
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hobby-Anwender'''

* Nicht direkt "Steckbrettauglich", da kein DIL Gehäuse verfügbar. Der ebay-Shop dipmicro führt jedoch sehr günstige Lötadapter für Umsetzung von LQFP48 auf DIP48. QFP64 in 0.5mm Pinabstabd und nicht 0.8mm wie AVR

'''

== Hardware-Beschaltung ==

Der STM32 benötigt für den Betrieb nur (Minimalbeschaltung):

* VCC 2..3,3V (je nach Typ)
* AVCC 2..3,3V (sehr wichtig, der STM32 lässt sich ohne diese Spannung nicht programmieren)
* GND
* Reset Pin 100nF nach GND (ein Pull-Up Widerstand von ca. 40k ist intern vorhanden)
* Boot-Pins: Boot0 -> GND | Boot1 -> Egal ---> Mit der Konfiguration wird kein Bootloader gestartet

ansonsten nur ein paar einzelne Cs 100nF an VCC/GND.

Um Programmieren zu können wird entweder noch die serielle Schnittstelle (Programmieren über den vorprogrammierten Bootloader) oder JTAG oder die SWD Schnittstelle benötigt.

== Programmierung ==

Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden. Es ist für den Einsteiger schwierig herauszufinden welche Open-Source Programme man braucht damit es funktioniert, daher hier eine Zusammenstellung:

* [http://www.eclipse.org Eclipse]
* [http://www.yagarto.de Yagarto Tools] oder [http://www.codesourcery.com/sgpp/lite_edition.html Codesourcery Lite Edition] oder [https://launchpad.net/gcc-arm-embedded Launchpad]
* Programmieradapter OOCD, Turtelizer2 oder andere JTAG Programmieradapter
* Eclipse Plugin "GDB Hardware Debugging" mit [http://www.firefly-power.de/ARM/debugging.html OpenOCD server]
* [http://www.st.com/internet/com/software/ides_mcu.jsp#stm32 ST Liste: IDEs, Toolsets and Debug tools for MCUs]

* Zum Starten eine fertige Zusammenstellung: [http://www.mikrocontroller.net/topic/216554 Eclipse+codesourcery+st-link]

* [http://www.coocox.org/ Coocox Eclipse IDE] kostenlose IDE für Cortex M0/M3. Hilfreiche Infos gibt es im [http://www.mikrocontroller.net/topic/214719?goto=new#2228482 hier] und [http://www.mikrocontroller.net/topic/214719?goto=new#2229943 hier] Forum

* [http://www.mikrocontroller.net/topic/265600 STM32F4 mit Code::Blocks]

* [http://emide.org/ emIDE] kostenlose IDE die mit dem Segger J-LINK funktioniert.

Sehr nützlich für Linux-Anwender auch diese Seite: [http://fun-tech.se/stm32/index.php STM32/ARM Cortex-M3 HOWTO: Development under Ubuntu.]

Folgende kommerzielle Umgebungen sind verfügbar:

* [http://www.keil.com Keil µVision] (Demo max. 32KB Code): Die sehr komfortable µVison IDE ist neben dem ARM Compiler per Menue auch für einen beliebigen GNU-Compiler konfigurierbar. Damit besteht das 32k-Limit nur noch für den integrierten Debugger / Simulator. µVison selbst kann kostenlos mit dem MDK-Evaluationkit heruntergeladen werden.
* [http://www.iar.com IAR] (Demo max. 32KB Code)
* [http://www.raisonance.com Raisonance Ride7] (GCC Compiler, kostenlose Version auf Debugging von max. 32KB Code limitiert, keine Limitierung beim Complilieren)
* [http://www.atollic.com Atollic] (Lite Version (bis V2.3.0) ohne Code-Limit, auf GCC basierend. Die neueste Version ab V3 hat fast keine Beschränkungen mehr außer jetzt einen Code-Limit von 32kB. Außerdem werden jetzt die meisten ARM Familien unterstützt. )
* [http://www.coocox.org CoIDE] (Kostenlose GCC, Eclipse basierende IDE mit einem Code-Generator Tool)
* [http://www.rowley.co.uk/arm/ Rowley Crossworks] (Demo 30 Tage unbeschränkt, 150$ für nichtkommerzielle Nutzung, auf GCC basierend)
* [http://www.code-red-tech.com Code Red] (GCC basierend)

Programmieradapter
* [http://www.segger.com J-Link / J-Trace] Cortex-M3, als [http://www.segger.com/cms/j-link-edu.html NonComercial] J-Link für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* [http://olimex.com/dev/index.html Olimex] ARM-USB-OCD (ca. 60.-)
* Keil [http://www.keil.com/arm/ulink2/ ULINK2], [http://www.keil.com/arm/ulinkpro/ ULINK pro]
* [http://www.st.com/internet/evalboard/product/219866.jsp ST-LINK], [http://www.st.com/internet/evalboard/product/251168.jsp ST-LINK/V2]
*[http://www.st.com/internet/com/press_release/p3065.jsp STM32xx Discovery] jedes STM32 Discovery board hat einen ST-Link für Programmierung/Debugging per SWD on-board, welcher auch für eigene STM32 Target Hardware benutzt werden kann (ca. 12,- bis 19,-€, je nach Typ).
* [http://www.raisonance.com/~rlink-debugger-programmer__microcontrollers__tool~tool__T018:4cn9ziz4bnx6.html Raisonance RLink]
* [http://www.amontec.com Amontec]
* [http://www.hjtag.com H-JTAG] Personal Edition für ca. 60,- zu haben, läuft mit ADS, SDT, IAR, Vision und RVDS

Programmieradapter Open-Source
* [http://www.oocdlink.com/ OOCDLink]
* [https://github.com/texane/stlink Stlink]
* [http://www.randomprojects.org/wiki/Floss-JTAG FLOSS-JTAG]
* [http://capitanio.org/mlink/ Linux Demo Code für die Discovery's ST-Link Programmierung]

Der Controller hat auch einen fest eingebauten Boot-Lader. Damit läßt er sich auch über eine gewöhnliche serielle Schnittstelle programmieren, ohne daß man einen JTAG-Adapter benötigt.

Tipps für Installation mit Eclipse können in [http://www.mikrocontroller.net/topic/214719 diesem Thread] gelesen werden.

=== Installation für STM32 (Linux) ===

==== Variante A ====

* Benötigte Hardware
** Ein Desktop PC oder Laptop mit Linux OS (openSuSE, Ubuntu, ...) alternativ: Ein Windows System mit Linux in einer virtuellen Maschine
** root Zugang zum Linux OS (superuser Passwort)
** GNU C Compiler
** Programmer ARM-USB-TINY-H (optimal) alternativ: OpenOCD kompatiblen Programmer
** Prototypboard Olimex STM32-P107 (optimal) alternativ: irgendein board mit STM32 uC und JTAG Port

* Download + Installation (in einem Terminal)
wget http://hlb-labor.de/cortexm3/install_ToolChain_STM32.sh
chmod +x install_ToolChain_STM32.sh
./install_ToolChain_STM32.sh

Die Installation sollte im Idealfall voll automatisch durchlaufen. Anschliessend wird ein Beispielprojekt mit Multitasking OS und LED-Heartbeat kompiliert und auf den uC programmiert.
Für andere Protoboards/ Programmer muss die ToolChain entsprechend der readme Anleitung umkonfiguriert werden.

Das Projekt kann im QtCreator (http://qt.nokia.com/) geöffnet und bearbeitet werden.

==== Variante B ====

Die Installation einer Toolchain (Make, Flash, Debug via JTAG, IDE) ist in folgendem Manual beschrieben:

"How-to manual - Installing a toolchain for Cortex-M3/STM32 on Ubuntu 10.04"

*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.pdf
*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.odt

Die Beschreibung im OpenOffice Format erlaubt die Weiterbearbeitung des Textes und das Entnehmen von Quelltexten ohne den Verlust von Formatierungen.

Verwendete Hardware:
*JTAG device
**Olimex “ARM-USB-OCD-H”, basierend auf FTDI “FT2232H”
*Microcontroller
**Olimex “STM32-H103” basierend auf STM32F103RBT6 mit 128KB Flash, 20KB RAM, 3xUART, ...
Die Toolchain sollte sich leicht an andere "FT2232" basierte JTAG Probes und "Cortex-M3" Derivate anpassen lassen.

Das Manual umfasst die Installation und Inbetriebnahme sowie Hinweise und Bug-fixes zu folgenden Komponenten:
*OpenOCD
*stm32flash
*Sourcery CodeBench Lite for ARM EABI
*STM32F10x standard peripheral library
*Project templates
*Makefiles
*Linker Sript
*Startup Code
*Doxygen
*Git
*Terminal emulation
*Eclipse IDE
*Links zu Datenblättern, Manuals und Toools

=== Installation für STM32 (Windows) ===

Hier ist der Anfang des Artikels [[STM32 Eclipse Installation]], hier ist neueres beschrieben als hier aufgeführt. Wenn der Artikel fertig ist, dann wird dieser Teil gelöscht.

* Eclipse "Helios" installieren mit GNU ARM Eclipse Plug-in
Eclipse IDE for C/C++ Developers<ref>http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliosr</ref> downloaden und installieren

* GNU ARM Eclipse Plug-in<ref>http://sourceforge.net/projects/gnuarmeclipse/</ref> runterladen und installieren. [http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page Weitere Infos].

Wird CodeSourcery G++ Lite verwendet, so muss die PATH Variable angepasst
werden, damit das Plugin die CodeSourcery exe-Files findet<ref>für Discovery notwendig</ref>. Alternativ das eclipse von einem script aus starten und zuerst den PATH erweitern.

Soll das ST-LINK verwendet werden, so kann der Atollic ST-LINK GDBSERVER aus der Atollic free version genutzt werden. Mit dem gdbclient im Eclipse kann damit problemlos geflasht und gedebuggt werden (JTAG und SWD).

Neuere Versionen von OpenOCD können ebenfalls mit STLINK und STLINK2 Kontakt aufnehmen. Bei vorkompilierten OpenOCD-Packeten (z.B. die von Freddy Chopin) mit libusb-Support und installiertem Herstellertreiber von STM ist noch der libusb-Filtertreiber einzurichten (relativ einfach per libusb-win32 filter wizard GUI).

Die Startup- und Linkerscripts der Atollic free version können für ein Projekt in dieser Konstallation genutzt werden.

* Eclipse "Galileo" installation<ref>[http://www.eclipse.org/] → Downloads → "Eclipse IDE for C/C++ Developers (79 MB)</ref>. Und das Servicepack 1<ref>[http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/SR1/eclipse-cpp-galileo-SR1-win32.zip Eclipse SR1]</ref>
Entpacken der Datei eclipse-cpp-galileo-SR1-win32.zip nach "C:\WinARM\" (Ordner neu erstellen)

* Eclipse PlugIn<ref>http://download.eclipse.org/tools/cdt/releases/galileo</ref> hinzufügen: Help → Install New Software... → "Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

* Yagarto Tools<ref>[http://www.yagarto.de/] "Download (for Windows)" → "YAGARTO Tools" http://www.yagarto.de/download/yagarto/yagarto-tools-20091223-setup.exe Installieren, Auswahl Verzeichnis "C:\WinARM\yagarto-tools"</ref>

* CodeSourcery: Achtung! Die Menustruktur ändert sich durchaus mal, dann suchen gehen. http://www.codesourcery.com/ → Products → Sourcery G++ → Editions>Lite Edition → ARM → Downloads. Direkter Download<ref>[http://www.codesourcery.com/sgpp/lite/arm/portal/package6496/public/arm-none-eabi/arm-2010q1-188-arm-none-eabi.exe]</ref>. Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD: Kompilierte Version für Windows<ref>[http://www.freddiechopin.info/] → Download → Software → OpenOCD</ref> installieren nach "C:\WinARM\OpenOCD_0_4_0" ist auch auf der Seite<ref>[http://yagarto.de/#ocd Yagarto.de]</ref> beschrieben. PS: Sollte der Olimex ARM-USB-OCD verwendet werden, dann darf nicht der Treiber von Olimex verwendet werden, sondern der vom OpenOCD Download<ref>[http://www.mikrocontroller.net/topic/173753#1668913]</ref>.

* ST Firmware: http://www.st.com → Auswahl CPU STM32F103xxx → "Firmware" "STM32F10x_StdPeriph_Lib"<ref>http://www.st.com/mcu/devicedocs-STM32F103RC-110.html</ref>. Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.4.0\

=== Installation für STM32 auf einem zweiten Rechner===

* Kopieren des Verzeichnisses C:\WinARM\ (Zuvor wurden aus diesem Grund alle Setup-Pakete nach C:\WinARM\... installiert)
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM\.... Verzeichnissen nachführen
* Fertig.

=== Installation für STM32 mit AtollicTrueStudio (+Demo) ===
* Installation + Demo: [[STM32 LEDBlinken AtollicTrueStudio]]

== Demo-Projekte ==

* [[prog_bsp_timer_1_timer2|Programmbeispiel für die Verwendung von Timer2 zusammen mit dem Interrupt]]
* [http://www.firefly-power.de/ARM/printf.html Printf() debugging mit minimalem Aufwand]
* [[STM32_BLDC_Control_with_HALL_Sensor|Programmbeispiel für BLDC Motoransteuerung (Timer 1) mit HALLSensor (Timer 3)]]
* [[Cortex_M3_OCM3U]]
* Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:
** [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html "ChaN's FAT-Module with STM32 SPI"]
* [[STM32 USB-FS-Device Lib]]
* Modellbau-Sender auf STM32-Basis mit vielen Treibern [http://www.rcos.eu www.rcos.eu]
* Ausführliches [https://github.com/jkerdels/stm32edu Einstiegs-Tutorial] in Codeform für das [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4 discovery board]

== Errata, Tipps und Tricks ==

* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 9.3.3.: "CAN1 alternate function remapping". Alle Infos von RM0008 9.3.x sind interessant
* CAN und USB sind nur bei der "◦Connectivity-Line" gleichzeitig nutzbar. Siehe Datenblätter.
* Mit internem RC-Oszillator kann die CPU mit maximal 64MHz betrieben werden. Mit einem externen Quarz sind dann 72MHz möglich.
* Für USB Betrieb muss die CPU mit 48MHz oder 72MHz betrieben werden (bei STM32F1xx).
* Der Idle Interrupt vom Usart wird zwar ausgelöst, aber nicht vom entsprechenden Statusflag angezeigt
* Der DMA fängt beim aktivieren immer von vorn an zu zählen, auch wenn er nur kurz angehalten wurde
* STM32F2xx hat kein Flash Size Register, bei STM32F4xx ist zwar ein flash Size Register beschrieben, kollidiert aber in der Adresse mit einem anderen Register
* Derivate mit internem EEPROM und nur einer Speicherbank haben das "Feature" bei write/erase des Data-Flashes (EEPROM) einen kompletten stall der code execution zu verursachen (inkl. ISR's, DMA). Desgleichen bei write/erase des internen Flash (ISP-routinen, EEPROM-Emulation).

=== Tipps für Umsteiger von Atmel/PIC/8051 ===
* Prozessortakt hat unterschiedliche Taktquellen und eine PLL.
* Alle Peripheriemodule haben einen extra Clock, den man aktivieren muss.
* Wenn man z.B. einen UART benutzen möchte, so muss man den Clock vom UART, Alternate Function IO (AFIO) und dem GPIO-Port aktivieren.
* Ansonsten hat man nahezu doppelt so viele Möglichkeiten in den Peripheriemodulen.
* Interrupt-Flags müssen in der ISR selber gelöscht werden
* Forum zu [http://www.mikrocontroller.net/topic/175888 Interrupts vs. Events]

=== Tipp FPU von STM32F4xx nutzen ===
Es benötigt dafür 2 Dinge, zum einen muss die Compileroption gesetzt sein, zum anderen auch die FPU aktiviert werden:

Compileroption:

<code>COMMON_FLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16</code>

Der Code für das Aktivieren der FPU:

<c>/*FPU settings*/
__asm volatile ("ldr r0, =0xE000ED88"); /* Enable CP10,CP11 */
__asm volatile ("ldr r1,[r0]");
__asm volatile ("orr r1,r1,#(0xF << 20)");
__asm volatile ("str r1,[r0]");
</c>

Ohne Inline-Assembler in C wie in system_stm32f4xx.c aus den Beispielen von ST-Microelectronics:
<c>
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
</c>

Weiterhin sollte die Toolchain auch Laufzeitbibliotheken mit FPU-Unterstützung mitbringen (CodeBench lite wird ohne ausgeleifert, GCC for ARM embedded von launchpad.org mit).

Mehr dazu in diesem Thread: [http://www.mikrocontroller.net/topic/261021 Floating Pointing Unit STM32F4]

=== Errata vom STM32F4xx die nicht im Errata von ST stehen ===
* [http://www.mikrocontroller.net/topic/267439#2788478 Aktivieren von DMA], wenn mehr als 3 DMA Kanäle aktiviert werden, kann es sein dass die nicht alle korrekt bedient werden. Auch klappt der DMA mit dem FSMC nicht immer zuverlässig. [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FWarning%20limit%20simultaneous%20DMAs%20to%202&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=811 siehe hier] [http://blog.frankvh.com/2012/01/13/stm32f2xx-stm32f4xx-dma-maximum-transactions/ und hier]
* [http://www.mikrocontroller.net/topic/260637#2700761 Nerviger Bug in "stm32f4xx.h"] Änderung Struktur GPIO_TypeDef
* [http://www.mikrocontroller.net/topic/261690#2714754 Batterie wird leer gezogen], nur bei manchen Chips mit Rev. A

== Bezugsquellen ==

=== Controller ===

Versandhäuser für Privatpersonen

* [http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html Darisus]
* [http://www.hbe-shop.de HBE (Farnell Programm für Private)]
* [http://www.sander-electronic.de/be00069.html Sander]
* [http://www.rs-online.com RS-Online]
*[http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+ TME]
* [https://www.distrelec.de/ishopWebFront/catalog/product.do/para/keywords/is/STM32_ARM-Microcontroller/and/language/is/de/and/shop/is/DE/and/series/is/1/and/id/is/01/and/node/is/34910.html Distrelec]

Gewerblich liefern natürlich viele wie Mouser, Farnell, Digikey usw...

=== Evaluation Boards ===

* [http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14 Im Shop von Embedded Projects]
* [http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3 Cortex M3 bei Watterott]
* [http://www.raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer und Primer2 von Raisonance]
* [http://www.sander-electronic.de/es0028.html Sander Electronic]
* [http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher Artikel im Wiki, ARM mit USB und 4MB Speicher]
* [http://www.futurlec.com/STM32_Development_Board.shtml Futurlec Evalboard, ebenso Header-Board]
* [http://www.propox.com/products/t_174.html Propox, Header-Boards für 103R und 103V sowie Trägerplatine dafür]
* [http://www.mikrocontroller.net/articles/Cortex_M3_OCM3U Cortex M3 Artikel im Wiki]
* [http://olimex.com/dev/index.html STM32 bei Olimex]
* [http://de.farnell.com/jsp/displayProduct.jsp?sku=1824325&action=view&CMP=GRHS-1000962 STM32Discovery bei Farnell] Mikrocontroller Board (STM32F100RBT6B) mit onboard USB-Programming Interface für ca. 12,50€
* [http://www.de.rs-online.com/web/p/products/7458434/ STM32Discovery bei RS-Components] 12,65 € +MwSt.
* [http://www.segor.de/#Q=STM32 VL DISCOVERY] STM32 Discovery bei Segor
* [http://www.watterott.com/de/STM32F4Discovery STM32F4DISCOVERY] STM32F4 Cortex M4 Controller mit JTAG-Debugger auf der Platine bei Watterott für 16,66EUR.
* [http://www.steitec.net/ARM-Boards/ Steitec, STM32F103 Cortex M3 Board 34,80€]
* [http://www.mcu-raisonance.com/~open4-development-platform__microcontrollers__tool~tool__T018:g65gu6ghg2n.html/ Open 4 oder auch genannt Evo-Primer]
* [http://www.wayengineer.com/index.php?main_page=index&cPath=50_66&page=1&sort=3a WayEngineer]

== Weblinks, Foren, Communities ==

* [http://www.mikrocontroller.net/topic/173753 Diskussion zum Artikel]
* [http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex* Suche im Forum]
* [https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx Forum auf der ST Homepage]
* [http://www.stm32circle.com/hom/index.php STM32 Community]
*[http://www.arm-forum.de Deutsches ARM-Forum]
*[http://joe-c.de/pages/posts/einstieg_mikrocontroller_stm32f103_101.php Einstieg: STM32board mit Kamera (deutsch)]
* [http://www.ebv.com/fileadmin/products/Press_Print/Brochures/Product_Brochures/EBV_Cortex%20Collection_V2.pdf Übersicht der Cortex Prozessoren und deren Hersteller (nicht nur ST, von EBV)]
* [http://www.mikrocontroller.net/topic/258652 Tutorial]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

STM32

2012-08-22T17:30:40Z

Mthomas: /* Tipp FPU von STM32F4xx nutzen */

STM32 ist ein Mikrocontroller-Familie von [http://www.st.com/mcu/inchtml-pages-stm32.html ST] mit einer 32-Bit [http://www.arm.com/products/processors/cortex-m/index.php ARM Cortex-M3/M4] CPU. Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt und löst damit die bisherigen ARM7-basierten Controller weitestgehend ab. Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrößen und -formen. Durch die geringe Chipfläche des Cores ist es ST möglich, eine 32 Bit-CPU für weniger als 1 € anzubieten.

[[Bild:stm32F103xc.png|thumb|right|340px|Blockdiagramm STM32F103xC/D/E]]

== STM32-Familien ==

Bisher gibt es sieben STM32-Familien:
* [http://www.st.com/internet/mcu/subclass/1588.jsp STM32F0]
** Cortex M0
** µC zum Einstieg
* [http://www.st.com/internet/mcu/subclass/1169.jsp STM32F1]
** Cortex M3
*** Connectivity line
*** Performance line
*** USB Access line
*** Access Line
*** Value line
* [http://www.st.com/internet/mcu/product/250173.jsp STM32F2]
** Cortex M3
** Wie die STM32F1 Serie, jedoch 120MHz, Camera-Interface, 32-Bit Timer, Crypto-Engine...
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3]
** ARM® Cortex™-M4-based STM32 F3, 72MHz
** DSP instructions and the floating point unit
** Fast 12-bit 5 MSPS and precise 16-bit sigma-delta ADCs
* [http://www.st.com/internet/mcu/subclass/1521.jsp STM32F4]
** Cortex M4
** ARM® Cortex™-M4-based STM32 F4, 168MHz
** DSP instructions and the floating point unit
* [http://www.st.com/mcu/inchtml-pages-stm32l.html STM32L]
** Cortex M3
** Low Power
** mit LCD Treiber
* [http://www.st.com/mcu/inchtml-pages-stm32w.html STM32W]
** Cortex M3
** RF-MCU
[http://www.st.com/internet/mcu/class/1734.jsp Hier eine Übersicht zum Auswählen eines STM32Fxxx]

'''Features'''
* Cortex-M3 bzw. Cortex-M4 Kern in der STM32F4xx Serie
* 16KB ... 1MB [[Flash-ROM]]
* 4KB ... 192KB [[Speicher#SRAM|SRAM]]
* 4KB [[Speicher#EEPROM|EEPROM]] (STM32L)
* 512 one-time programmable Bytes(STM32F2/4)
* [[IC-Gehäuseformen | Gehäuse]] 36 ... 176 Pins als QFN, LQFP und BGA
* Derzeit sind über '''250''' STM32 Derivate/Varianten verfügbar
* Bis 72MHz CPU-Takt, bis 120MHz beim STM32F2xx, bis 168 MHz beim STM32F4xx, wobei eine spezielle prefetch-hardware bis 120/168 MHz eine Geschwindigkeit erzielen soll, die 0 Wait-States entspricht. Der CPU-Takt wird über einen Multiplikator aus dem internen RC-Takt oder einem externen Quarz-Takt abgeleitet.
* Externes Businterface (nur bei Gehäusen ab 100 Pin und nur bei STM32F4, STM32F2 und STM32F1 Performance line)
* LCD Treiber für 8x40 Punkte (nicht beim STM32F2xx)
* Spannungsbereich 1,65 ... 3,6V, nur eine Betriebsspannung nötig
* Temperaturbereich bis 125 °C
* Bis zu 140 IOs, viele davon [[Pegelwandler|5V-tolerant]]
* Interner, kalibrierter RC-Oszillator mit 8MHz (16MHz bei STM32F2xx)
* Externer Quarz
* Real Time Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 16 [[Timer]], je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer (bei STM32F103xF/G)
* Systick Counter
* Bis zu 3 12-Bit [[AD-Wandler]] mit insgesamt 24 AD-Eingängen, integrierter [[Temperatursensor]], Referenzspannung Vrefint und VBatt Spannungsmessung (STM32F4xx)
* Bis zu 2 12-Bit [[DA-Wandler]]
* Bis zu 2 [[DMA]] Controller mit bis zu 12 Kanälen (16 beim STM32F2xx)
* Bis zu 2x [[I2C|I²C]]
* Bis zu 5x [[UART|USART]] mit LIN, IrDA und Modem Control (6 beim STM32F2xx)
* Bis zu 3x [[SPI]]
* Bis zu 2x [[I2S|I²S]]
* Bis zu 2x [[CAN]]
* Unique device ID register (96 Bits)
* RNG - Random Number Genrator (STM32F2xx)
* Cryptographic Processor (CRYP) (STM32F2xx)
* Hash Processor (HASH) (STM32F2xx)
* Kamera-Interface (DCMI) (STM32F2xx)
* [[USB]] 2.0 Full Speed / OTG
* [[USB]] 2.0 Hi Speed OTG mit extra PHY-Chip (STM32F2xx)
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich [[Ultra low power|Strom sparen]] lässt
* [[JTAG]] und SWD (Serial Wire Debug) Interface
* Bis zu 6 Hardware-Breakpoints für Debuggen
* und vieles mehr . . .

== Struktur der Dokumentation: ==

Als Beispiel der Dokumentation soll stellvertretend der [http://www.st.com/mcu/devicedocs-STM32F103RC-110.html STM32F103RC] genannt werden. Die Seite von ST beinhaltet alle nötigen Informationen passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00191185.pdf Datasheet STM32F103xC/D/E]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf Reference Manual (RM0008)]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/PROGRAMMING_MANUAL/CD00228163.pdf Cortex-M3 Programming Manual]
* [http://www.st.com/stonline/products/literature/pm/13259.pdf Flash Programming Reference]

Im Datasheet sind die speziellen Eigenschaften einer bestimmten Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für eine STM32-Familie. Details zum Prozessorkern selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich die Flash Programming Reference für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates. Hinzu kommen optionale Dokumente von ARM, die den [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337-/ Cortex-M3 Kern] / [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0439c/index.html Cortex-M4 Kern] beschreiben. Hier gibt es den Opcode wenn man ihn in [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0403-/ Assembler] programmieren möchte. Zusätzlich sollten auch die [http://www.st.com/stonline/products/literature/es/14732.pdf Errata Sheets] beachtet werden. Empfohlen sei auch die Appnote "[http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/APPLICATION_NOTE/CD00164185.pdf STM32F10xxx hardware development: getting started]".

== ‎STM32F10x Standard Peripherals Library ==

ST bietet eine umfangreiche Firmwarebibliothek, eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST (gibt es beispielsweise auf den Cortex-M3 Controllern von TI auch, ist teilweise in einem separaten ROM untergebracht). Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern. Diese Library und ihre Dokumentation setzen das grundlegende Verständnis der Funktion des jeweiligen Peripheriemoduls voraus, wie es die o.A. Referenz und diverse Appnotes vermitteln. Diese FW-Lib (Download von ST) ist ein MUSS für jeden, denn darin sind auch jede Menge Beispiele für alle Peripheriemodule.

Details siehe: [[‎STM32F10x Standard Peripherals Library]].

Mit [http://www.libopencm3.org/wiki/Main_Page libopencm3] ist derzeit auch eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library in Entwicklung, die zukünftig auch Cortex-M3 Controller von anderen Herstellern unterstützen soll.

== CMSIS ==

Parallel zur Firmware-Library (FW-Lib) gibt es für die "Selbermacher" die CMSIS (ARM® '''C'''ortex™ '''M'''icrocontroller '''S'''oftware '''I'''nterface '''S'''tandard), die grundsätzlich nur den herstellerübergreifenden ARM-Core abdeckt. Hierzu gehört bei den Cortex-M4-Cores auch die DSP und Floating-Point Funktionalität. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, den Sys-Tick-Counter, sowie eine SystemInit-Funktion, welche sich um die PLL kümmert.

Im Rahmen des CMSIS-Standards ([http://www.onARM.com www.onARM.com]) wurden die Headerdateien standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Die CMSIS C-Dateien bzw. Header enthalten auch Anpassungen für die verschiedenen Compiler. Die Portierung eines Real-Time-Betriebsystems sollte unter Verwendung der CMSIS, für Chips der verschiedenen Hersteller, stark vereinfacht möglich sein (z.B. einheitliche Adressen für Core-Hardware/Sys-Tick-Counter).

Die CMSIS ist im Download der FW-Lib enthalten. Die Compiler-Hersteller liefern eine jeweils zur ihrer Tool-Version passende bzw. geprüfte FW-Lib (incl. CMSIS) aus. Diese Libs können, gegenüber den Downloads beim Chip-Hersteller, auch ältere Version beinhalten.

== Debug- und Trace-Interface (CoreSight™ Debug and Trace Technologie)==

Übersicht über beide Funktionalitäten und den Schnittstellen:
http://www.keil.com/support/man/docs/ulink2/ulink2_cs_core_sight.htm

Die Coresight-Debug-Architektur ermöglicht ein nicht-invasives Debugging, d.h. es können während des Betriebes (meistens) ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Debugger Funktionen ===

Der Debugger-Teil besitzt drei Funktionen:
* Run Control: z.B. Programm-Start, Stopp und Einzel-Schritte.
* (Program) Break Points: Ein Programm hält an, wenn der Programm Counter eine bestimmte Programm-Adresse erreicht.
** Beinhaltet keine Data Watch Funktionalität, welche im Trace-Teil (DWT) realisiert wird.
* Memory Access: Lesen und Schreiben von Speicheradressen.
** Diese Funktionalität beinhaltet keine direkte Flash-Programmierung. Der Programmiervorgang für einen Flash ist herstellerspezifisch und muss von dem verwendeten Debugger unterstützt werden.

=== Trace Funktionen ===
Die Trace-Funktionalität wird in drei Funktionen aufgeteilt:
* ETM (Embedded Trace Macrocell): Optional, nicht jede CPU besitzt diese Hardware (Kostenfaktor, Austattung).
* ITM (Instrumentation Trace Macrocell): Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht werden, sowie "printf-ähnlich" Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.
* DWT (Data Watchpoint & Trace Unit):
** Data Watch: 4 Access-Break-Points ( z.B. der Debugger bleibt stehen, wenn das Programm auf einen Speicher zugreift oder der Wert einer Variablen einen bestimmten Wert annimmt).
** Trace Unit: Programmverlauf (durch Lesen des Program Counters) und Interrupt Aufrufe verfolgen, sowie Zeitmessungen.

Einige der Trace-Funktionalitäten können über die JTAG-Schnittstelle angesprochen werden. Die schnelle Trace-Funktionalität (mit 4 bit Parallel-Port) steht nur mit der erweiterten DEBUG + ETM Schnittstelle zur Verfügung. Im Gegensatz zum Debugger-Teil (Run Control, Break Points und Memory Access) werden Trace-Funktionen nicht von allen Debuggern unterstützt. Debugger mit der vollen Trace-Funktionalität kosten deutlich mehr.

* Beispiele für Trace-Port-Aktivierungen für verschiedene Hersteller: http://www.keil.com/support/man/docs/jlink/jlink_capture_tracedata.htm

Die Aktivierung des parallelen Trace-Ports erfordert, je nach CPU Hersteller, zusätzliche Debugger-Makros für die Aktivierung und Port-Freischaltung. Zusätzlich sind die Schnittstellenauswahl und Einstellung (Frequenzen) im Entwicklungs-Tool (IDE) wichtig, um erfolgreich den Programm-Verlauf "tracen" zu können.

=== Debug und Trace-Schnittstellen ===
Als Debug Interface stehen zwei Varianten zur Auswahl:
* [[JTAG]]: Dafür sind mindestens 6 Steuerleitungen nötig.
* SWD (Serial Wire Debug): Hier mindestens 2 Steuerleitungen (3 mit SWO, zzgl GND und 3,3V). Die SWD Schnittstelle ist in der Regel schneller und kann auch Funktionen aus dem Trace-Teil beinhalten (z.B. ITM, dafür wird der SWO-Pin benötigt).

Standard-JTAG Steckerbelegungen:
http://www.keil.com/support/man/docs/ulink2/ulink2_hw_connectors.htm

=== Der 10polige JTAG-Stecker von mmvisual ===
mmvisual hat mit dieser Steckerbelegung die Standard JTAG Schnittstelle erweitert:

Ich habe diesen Part in den Artikel [http://www.mikrocontroller.net/articles/JTAG#Der_10-Polige_JTAG_Stecker_von_mmvisual JTAG] verschoben.
Hinzu gekommen ist die Adapterplatine 10-Polig auf Standard JTAG 20 Polig mit TTL/V24 Wandler. [http://www.mikrocontroller.net/articles/JTAG#Die_Adapterplatine Siehe hier.]

=== STM32 RS232 (CAN und USB) Programmiertool ===

Auch ohne JTAG lässt sich ein STM32 programmieren (Bootloader-Aktivierung). Dabei stehen, je nach CPU-Typ, verschiedene Möglichkeiten zur Verfügung:
* RS-232 (bisher alle STMs)
* USB (nur in bestimmten MCUs mit entsprechender Bootloader-Version und PIN-Anzahl, z.B. STM32F105/107)
* CAN (wie USB nur in bestimmten MCUs)

3 zusätzliche Verbindungen müssen auf dem Board gepatcht werden. Für einen Test geht es auch mit Tastern für RESET und BOOT0. 
RESET=RTS (L-aktiv) 
BOOT0=DTR (H-aktiv) 
BOOT1=LOW 

Details sind hier im Forum: [http://www.mikrocontroller.net/topic/141711 STM32 Programmiertool]

== Vorteile ==

'''Vorteile gegenüber ARM7:'''

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vektortabelle, keine Sprungliste wie bei ARM7. Durch Automatismen zwischen Core und NVIC (auto register save r0..r3, lr, sp, pc) bei Interrupt Entry wird eine deutlich schnellere Ausführungszeit bei Interrupts erreicht. Der Interrupt Code muss sich nicht mehr selbst um die Sicherung der o.g. Register kümmern und eine besondere Konfiguration der Handler im Compiler entfällt. Sind vor Beendigung einer ISR (d.h. Rücksprung zum User Code) weitere Interrupts pending, so werden diese ausgeführt, ohne dass eine komplette pop-push-sequenz der Register notwendig ist. Schön beschrieben ist es hier im [http://www.st.com/mcu/files/mcu/1221142709.pdf Insider's Guide] unter 2.4.5 / Seite 20.
* Thumb-2 Befehlssatz, deutlich schneller als Thumb-1 und ebenso kompakt
* Weniger Pins für Debugging benötigt durch SWD
* Mehr Hardware Breakpoints machen debuggen einfacher
* Software ist einfacher weil die Umschaltung zwischen ARM Mode und Thumb Mode wegfällt

'''Vorteile gegenüber LPC1700 und LPC1300:'''

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* FW-Lib für alle STM32 gleich, alle AppNotes/Demos beziehen sich auf diese eine FW-Lib was die Entwicklung der eigenen Applikation sehr beschleunigt.
* Genauerer und flexiblerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010) Allerdings gibts den LPC1100 mit Cortex-M0 schon ab 0,65 $!
'''Nachteil gegenüber LPC1700:'''
* STM32F1xx: nur 72 MHz statt 100 MHz (LPC1759: 120 MHz) Taktfrequenz; STM32F2xx hat diesen Nachteil nicht (ebenfalls 120MHz, STM32F4xx mit 168MHz) (Aber NXP hat schon 150MHz angekündigt)
* Der LPC1700 besitzt deutlich mehr Mechanismen, um die Auswirkung der Waitstates des Flash-ROMs auf Code- und Datenzugriffe zu reduzieren und das bedeutet mehr Performance bei gleicher Taktfrequenz. Beim STM32F2 entfällt dieser Nachteil wohl aufgrund des ART accelerators.
* Alle LPC1xxx haben 32 Bit Timer. Bei den STM32 haben das nur die STM32F2xx (2 Stück)
* I2S Einheit von ST hat keinen FIFO und im 24/32Bit Modus müssen 2x16Bit Halbwörter übertragen werden.
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hobby-Anwender'''

* Nicht direkt "Steckbrettauglich", da kein DIL Gehäuse verfügbar. Der ebay-Shop dipmicro führt jedoch sehr günstige Lötadapter für Umsetzung von LQFP48 auf DIP48. QFP64 in 0.5mm Pinabstabd und nicht 0.8mm wie AVR

'''

== Hardware-Beschaltung ==

Der STM32 benötigt für den Betrieb nur (Minimalbeschaltung):

* VCC 2..3,3V (je nach Typ)
* AVCC 2..3,3V (sehr wichtig, der STM32 lässt sich ohne diese Spannung nicht programmieren)
* GND
* Reset Pin 100nF nach GND (ein Pull-Up Widerstand von ca. 40k ist intern vorhanden)
* Boot-Pins: Boot0 -> GND | Boot1 -> Egal ---> Mit der Konfiguration wird kein Bootloader gestartet

ansonsten nur ein paar einzelne Cs 100nF an VCC/GND.

Um Programmieren zu können wird entweder noch die serielle Schnittstelle (Programmieren über den vorprogrammierten Bootloader) oder JTAG oder die SWD Schnittstelle benötigt.

== Programmierung ==

Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden. Es ist für den Einsteiger schwierig herauszufinden welche Open-Source Programme man braucht damit es funktioniert, daher hier eine Zusammenstellung:

* [http://www.eclipse.org Eclipse]
* [http://www.yagarto.de Yagarto Tools] oder [http://www.codesourcery.com/sgpp/lite_edition.html Codesourcery Lite Edition] oder [https://launchpad.net/gcc-arm-embedded Launchpad]
* Programmieradapter OOCD, Turtelizer2 oder andere JTAG Programmieradapter
* Eclipse Plugin "GDB Hardware Debugging" mit [http://www.firefly-power.de/ARM/debugging.html OpenOCD server]
* [http://www.st.com/internet/com/software/ides_mcu.jsp#stm32 ST Liste: IDEs, Toolsets and Debug tools for MCUs]

* Zum Starten eine fertige Zusammenstellung: [http://www.mikrocontroller.net/topic/216554 Eclipse+codesourcery+st-link]

* [http://www.coocox.org/ Coocox Eclipse IDE] kostenlose IDE für Cortex M0/M3. Hilfreiche Infos gibt es im [http://www.mikrocontroller.net/topic/214719?goto=new#2228482 hier] und [http://www.mikrocontroller.net/topic/214719?goto=new#2229943 hier] Forum

* [http://www.mikrocontroller.net/topic/265600 STM32F4 mit Code::Blocks]

* [http://emide.org/ emIDE] kostenlose IDE die mit dem Segger J-LINK funktioniert.

Sehr nützlich für Linux-Anwender auch diese Seite: [http://fun-tech.se/stm32/index.php STM32/ARM Cortex-M3 HOWTO: Development under Ubuntu.]

Folgende kommerzielle Umgebungen sind verfügbar:

* [http://www.keil.com Keil µVision] (Demo max. 32KB Code): Die sehr komfortable µVison IDE ist neben dem ARM Compiler per Menue auch für einen beliebigen GNU-Compiler konfigurierbar. Damit besteht das 32k-Limit nur noch für den integrierten Debugger / Simulator. µVison selbst kann kostenlos mit dem MDK-Evaluationkit heruntergeladen werden.
* [http://www.iar.com IAR] (Demo max. 32KB Code)
* [http://www.raisonance.com Raisonance Ride7] (GCC Compiler, kostenlose Version auf Debugging von max. 32KB Code limitiert, keine Limitierung beim Complilieren)
* [http://www.atollic.com Atollic] (Lite Version (bis V2.3.0) ohne Code-Limit, auf GCC basierend. Die neueste Version ab V3 hat fast keine Beschränkungen mehr außer jetzt einen Code-Limit von 32kB. Außerdem werden jetzt die meisten ARM Familien unterstützt. )
* [http://www.coocox.org CoIDE] (Kostenlose GCC, Eclipse basierende IDE mit einem Code-Generator Tool)
* [http://www.rowley.co.uk/arm/ Rowley Crossworks] (Demo 30 Tage unbeschränkt, 150$ für nichtkommerzielle Nutzung, auf GCC basierend)
* [http://www.code-red-tech.com Code Red] (GCC basierend)

Programmieradapter
* [http://www.segger.com J-Link / J-Trace] Cortex-M3, als [http://www.segger.com/cms/j-link-edu.html NonComercial] J-Link für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* [http://olimex.com/dev/index.html Olimex] ARM-USB-OCD (ca. 60.-)
* Keil [http://www.keil.com/arm/ulink2/ ULINK2], [http://www.keil.com/arm/ulinkpro/ ULINK pro]
* [http://www.st.com/internet/evalboard/product/219866.jsp ST-LINK], [http://www.st.com/internet/evalboard/product/251168.jsp ST-LINK/V2]
*[http://www.st.com/internet/com/press_release/p3065.jsp STM32xx Discovery] jedes STM32 Discovery board hat einen ST-Link für Programmierung/Debugging per SWD on-board, welcher auch für eigene STM32 Target Hardware benutzt werden kann (ca. 12,- bis 19,-€, je nach Typ).
* [http://www.raisonance.com/~rlink-debugger-programmer__microcontrollers__tool~tool__T018:4cn9ziz4bnx6.html Raisonance RLink]
* [http://www.amontec.com Amontec]
* [http://www.hjtag.com H-JTAG] Personal Edition für ca. 60,- zu haben, läuft mit ADS, SDT, IAR, Vision und RVDS

Programmieradapter Open-Source
* [http://www.oocdlink.com/ OOCDLink]
* [https://github.com/texane/stlink Stlink]
* [http://www.randomprojects.org/wiki/Floss-JTAG FLOSS-JTAG]
* [http://capitanio.org/mlink/ Linux Demo Code für die Discovery's ST-Link Programmierung]

Der Controller hat auch einen fest eingebauten Boot-Lader. Damit läßt er sich auch über eine gewöhnliche serielle Schnittstelle programmieren, ohne daß man einen JTAG-Adapter benötigt.

Tipps für Installation mit Eclipse können in [http://www.mikrocontroller.net/topic/214719 diesem Thread] gelesen werden.

=== Installation für STM32 (Linux) ===

==== Variante A ====

* Benötigte Hardware
** Ein Desktop PC oder Laptop mit Linux OS (openSuSE, Ubuntu, ...) alternativ: Ein Windows System mit Linux in einer virtuellen Maschine
** root Zugang zum Linux OS (superuser Passwort)
** GNU C Compiler
** Programmer ARM-USB-TINY-H (optimal) alternativ: OpenOCD kompatiblen Programmer
** Prototypboard Olimex STM32-P107 (optimal) alternativ: irgendein board mit STM32 uC und JTAG Port

* Download + Installation (in einem Terminal)
wget http://hlb-labor.de/cortexm3/install_ToolChain_STM32.sh
chmod +x install_ToolChain_STM32.sh
./install_ToolChain_STM32.sh

Die Installation sollte im Idealfall voll automatisch durchlaufen. Anschliessend wird ein Beispielprojekt mit Multitasking OS und LED-Heartbeat kompiliert und auf den uC programmiert.
Für andere Protoboards/ Programmer muss die ToolChain entsprechend der readme Anleitung umkonfiguriert werden.

Das Projekt kann im QtCreator (http://qt.nokia.com/) geöffnet und bearbeitet werden.

==== Variante B ====

Die Installation einer Toolchain (Make, Flash, Debug via JTAG, IDE) ist in folgendem Manual beschrieben:

"How-to manual - Installing a toolchain for Cortex-M3/STM32 on Ubuntu 10.04"

*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.pdf
*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.odt

Die Beschreibung im OpenOffice Format erlaubt die Weiterbearbeitung des Textes und das Entnehmen von Quelltexten ohne den Verlust von Formatierungen.

Verwendete Hardware:
*JTAG device
**Olimex “ARM-USB-OCD-H”, basierend auf FTDI “FT2232H”
*Microcontroller
**Olimex “STM32-H103” basierend auf STM32F103RBT6 mit 128KB Flash, 20KB RAM, 3xUART, ...
Die Toolchain sollte sich leicht an andere "FT2232" basierte JTAG Probes und "Cortex-M3" Derivate anpassen lassen.

Das Manual umfasst die Installation und Inbetriebnahme sowie Hinweise und Bug-fixes zu folgenden Komponenten:
*OpenOCD
*stm32flash
*Sourcery CodeBench Lite for ARM EABI
*STM32F10x standard peripheral library
*Project templates
*Makefiles
*Linker Sript
*Startup Code
*Doxygen
*Git
*Terminal emulation
*Eclipse IDE
*Links zu Datenblättern, Manuals und Toools

=== Installation für STM32 (Windows) ===

Hier ist der Anfang des Artikels [[STM32 Eclipse Installation]], hier ist neueres beschrieben als hier aufgeführt. Wenn der Artikel fertig ist, dann wird dieser Teil gelöscht.

* Eclipse "Helios" installieren mit GNU ARM Eclipse Plug-in
Eclipse IDE for C/C++ Developers<ref>http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliosr</ref> downloaden und installieren

* GNU ARM Eclipse Plug-in<ref>http://sourceforge.net/projects/gnuarmeclipse/</ref> runterladen und installieren. [http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page Weitere Infos].

Wird CodeSourcery G++ Lite verwendet, so muss die PATH Variable angepasst
werden, damit das Plugin die CodeSourcery exe-Files findet<ref>für Discovery notwendig</ref>. Alternativ das eclipse von einem script aus starten und zuerst den PATH erweitern.

Soll das ST-LINK verwendet werden, so kann der Atollic ST-LINK GDBSERVER aus der Atollic free version genutzt werden. Mit dem gdbserver im eclipse kann damit problemlos geflasht und gedebuggt werden (JTAG und SWD). Die Startup- und Linkerscripts der Atollic free version können für ein Projekt in dieser Konstallation genutzt werden.

* Eclipse "Galileo" installation<ref>[http://www.eclipse.org/] → Downloads → "Eclipse IDE for C/C++ Developers (79 MB)</ref>. Und das Servicepack 1<ref>[http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/SR1/eclipse-cpp-galileo-SR1-win32.zip Eclipse SR1]</ref>
Entpacken der Datei eclipse-cpp-galileo-SR1-win32.zip nach "C:\WinARM\" (Ordner neu erstellen)

* Eclipse PlugIn<ref>http://download.eclipse.org/tools/cdt/releases/galileo</ref> hinzufügen: Help → Install New Software... → "Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

* Yagarto Tools<ref>[http://www.yagarto.de/] "Download (for Windows)" → "YAGARTO Tools" http://www.yagarto.de/download/yagarto/yagarto-tools-20091223-setup.exe Installieren, Auswahl Verzeichnis "C:\WinARM\yagarto-tools"</ref>

* CodeSourcery: Achtung! Die Menustruktur ändert sich durchaus mal, dann suchen gehen. http://www.codesourcery.com/ → Products → Sourcery G++ → Editions>Lite Edition → ARM → Downloads. Direkter Download<ref>[http://www.codesourcery.com/sgpp/lite/arm/portal/package6496/public/arm-none-eabi/arm-2010q1-188-arm-none-eabi.exe]</ref>. Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD: Kompilierte Version für Windows<ref>[http://www.freddiechopin.info/] → Download → Software → OpenOCD</ref> installieren nach "C:\WinARM\OpenOCD_0_4_0" ist auch auf der Seite<ref>[http://yagarto.de/#ocd Yagarto.de]</ref> beschrieben. PS: Sollte der Olimex ARM-USB-OCD verwendet werden, dann darf nicht der Treiber von Olimex verwendet werden, sondern der vom OpenOCD Download<ref>[http://www.mikrocontroller.net/topic/173753#1668913]</ref>.

* ST Firmware: http://www.st.com → Auswahl CPU STM32F103xxx → "Firmware" "STM32F10x_StdPeriph_Lib"<ref>http://www.st.com/mcu/devicedocs-STM32F103RC-110.html</ref>. Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.4.0\

=== Installation für STM32 auf einem zweiten Rechner===

* Kopieren des Verzeichnisses C:\WinARM\ (Zuvor wurden aus diesem Grund alle Setup-Pakete nach C:\WinARM\... installiert)
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM\.... Verzeichnissen nachführen
* Fertig.

=== Installation für STM32 mit AtollicTrueStudio (+Demo) ===
* Installation + Demo: [[STM32 LEDBlinken AtollicTrueStudio]]

== Demo-Projekte ==

* [[prog_bsp_timer_1_timer2|Programmbeispiel für die Verwendung von Timer2 zusammen mit dem Interrupt]]
* [http://www.firefly-power.de/ARM/printf.html Printf() debugging mit minimalem Aufwand]
* [[STM32_BLDC_Control_with_HALL_Sensor|Programmbeispiel für BLDC Motoransteuerung (Timer 1) mit HALLSensor (Timer 3)]]
* [[Cortex_M3_OCM3U]]
* Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:
** [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html "ChaN's FAT-Module with STM32 SPI"]
* [[STM32 USB-FS-Device Lib]]
* Modellbau-Sender auf STM32-Basis mit vielen Treibern [http://www.rcos.eu www.rcos.eu]
* Ausführliches [https://github.com/jkerdels/stm32edu Einstiegs-Tutorial] in Codeform für das [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4 discovery board]

== Errata, Tipps und Tricks ==

* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 9.3.3.: "CAN1 alternate function remapping". Alle Infos von RM0008 9.3.x sind interessant
* CAN und USB sind nur bei der "◦Connectivity-Line" gleichzeitig nutzbar. Siehe Datenblätter.
* Mit internem RC-Oszillator kann die CPU mit maximal 64MHz betrieben werden. Mit einem externen Quarz sind dann 72MHz möglich.
* Für USB Betrieb muss die CPU mit 48MHz oder 72MHz betrieben werden (bei STM32F1xx).
* Der Idle Interrupt vom Usart wird zwar ausgelöst, aber nicht vom entsprechenden Statusflag angezeigt
* Der DMA fängt beim aktivieren immer von vorn an zu zählen, auch wenn er nur kurz angehalten wurde
* STM32F2xx hat kein Flash Size Register, bei STM32F4xx ist zwar ein flash Size Register beschrieben, kollidiert aber in der Adresse mit einem anderen Register
* Derivate mit internem EEPROM und nur einer Speicherbank haben das "Feature" bei write/erase des Data-Flashes (EEPROM) einen kompletten stall der code execution zu verursachen (inkl. ISR's, DMA). Desgleichen bei write/erase des internen Flash (ISP-routinen, EEPROM-Emulation).

=== Tipps für Umsteiger von Atmel/PIC/8051 ===
* Prozessortakt hat unterschiedliche Taktquellen und eine PLL.
* Alle Peripheriemodule haben einen extra Clock, den man aktivieren muss.
* Wenn man z.B. einen UART benutzen möchte, so muss man den Clock vom UART, Alternate Function IO (AFIO) und dem GPIO-Port aktivieren.
* Ansonsten hat man nahezu doppelt so viele Möglichkeiten in den Peripheriemodulen.
* Interrupt-Flags müssen in der ISR selber gelöscht werden
* Forum zu [http://www.mikrocontroller.net/topic/175888 Interrupts vs. Events]

=== Tipp FPU von STM32F4xx nutzen ===
Es benötigt dafür 2 Dinge, zum einen muss die Compileroption gesetzt sein, zum anderen auch die FPU aktiviert werden:

Compileroption:

<code>COMMON_FLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16</code>

Der Code für das Aktivieren der FPU:

<c>/*FPU settings*/
__asm volatile ("ldr r0, =0xE000ED88"); /* Enable CP10,CP11 */
__asm volatile ("ldr r1,[r0]");
__asm volatile ("orr r1,r1,#(0xF << 20)");
__asm volatile ("str r1,[r0]");
</c>

Ohne Inline-Assembler in C wie in system_stm32f4xx.c aus den Beispielen von ST-Microelectronics:
<c>
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
</c>

Weiterhin sollte die Toolchain auch Laufzeitbibliotheken mit FPU-Unterstützung mitbringen (CodeBench lite wird ohne ausgeleifert, GCC for ARM embedded von launchpad.org mit).

Mehr dazu in diesem Thread: [http://www.mikrocontroller.net/topic/261021 Floating Pointing Unit STM32F4]

=== Errata vom STM32F4xx die nicht im Errata von ST stehen ===
* [http://www.mikrocontroller.net/topic/267439#2788478 Aktivieren von DMA], wenn mehr als 3 DMA Kanäle aktiviert werden, kann es sein dass die nicht alle korrekt bedient werden. Auch klappt der DMA mit dem FSMC nicht immer zuverlässig. [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FWarning%20limit%20simultaneous%20DMAs%20to%202&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=811 siehe hier] [http://blog.frankvh.com/2012/01/13/stm32f2xx-stm32f4xx-dma-maximum-transactions/ und hier]
* [http://www.mikrocontroller.net/topic/260637#2700761 Nerviger Bug in "stm32f4xx.h"] Änderung Struktur GPIO_TypeDef
* [http://www.mikrocontroller.net/topic/261690#2714754 Batterie wird leer gezogen], nur bei manchen Chips mit Rev. A

== Bezugsquellen ==

=== Controller ===

Versandhäuser für Privatpersonen

* [http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html Darisus]
* [http://www.hbe-shop.de HBE (Farnell Programm für Private)]
* [http://www.sander-electronic.de/be00069.html Sander]
* [http://www.rs-online.com RS-Online]
*[http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+ TME]
* [https://www.distrelec.de/ishopWebFront/catalog/product.do/para/keywords/is/STM32_ARM-Microcontroller/and/language/is/de/and/shop/is/DE/and/series/is/1/and/id/is/01/and/node/is/34910.html Distrelec]

Gewerblich liefern natürlich viele wie Mouser, Farnell, Digikey usw...

=== Evaluation Boards ===

* [http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14 Im Shop von Embedded Projects]
* [http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3 Cortex M3 bei Watterott]
* [http://www.raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer und Primer2 von Raisonance]
* [http://www.sander-electronic.de/es0028.html Sander Electronic]
* [http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher Artikel im Wiki, ARM mit USB und 4MB Speicher]
* [http://www.futurlec.com/STM32_Development_Board.shtml Futurlec Evalboard, ebenso Header-Board]
* [http://www.propox.com/products/t_174.html Propox, Header-Boards für 103R und 103V sowie Trägerplatine dafür]
* [http://www.mikrocontroller.net/articles/Cortex_M3_OCM3U Cortex M3 Artikel im Wiki]
* [http://olimex.com/dev/index.html STM32 bei Olimex]
* [http://de.farnell.com/jsp/displayProduct.jsp?sku=1824325&action=view&CMP=GRHS-1000962 STM32Discovery bei Farnell] Mikrocontroller Board (STM32F100RBT6B) mit onboard USB-Programming Interface für ca. 12,50€
* [http://www.de.rs-online.com/web/p/products/7458434/ STM32Discovery bei RS-Components] 12,65 € +MwSt.
* [http://www.segor.de/#Q=STM32 VL DISCOVERY] STM32 Discovery bei Segor
* [http://www.watterott.com/de/STM32F4Discovery STM32F4DISCOVERY] STM32F4 Cortex M4 Controller mit JTAG-Debugger auf der Platine bei Watterott für 16,66EUR.
* [http://www.steitec.net/ARM-Boards/ Steitec, STM32F103 Cortex M3 Board 34,80€]
* [http://www.mcu-raisonance.com/~open4-development-platform__microcontrollers__tool~tool__T018:g65gu6ghg2n.html/ Open 4 oder auch genannt Evo-Primer]
* [http://www.wayengineer.com/index.php?main_page=index&cPath=50_66&page=1&sort=3a WayEngineer]

== Weblinks, Foren, Communities ==

* [http://www.mikrocontroller.net/topic/173753 Diskussion zum Artikel]
* [http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex* Suche im Forum]
* [https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx Forum auf der ST Homepage]
* [http://www.stm32circle.com/hom/index.php STM32 Community]
*[http://www.arm-forum.de Deutsches ARM-Forum]
*[http://joe-c.de/pages/posts/einstieg_mikrocontroller_stm32f103_101.php Einstieg: STM32board mit Kamera (deutsch)]
* [http://www.ebv.com/fileadmin/products/Press_Print/Brochures/Product_Brochures/EBV_Cortex%20Collection_V2.pdf Übersicht der Cortex Prozessoren und deren Hersteller (nicht nur ST, von EBV)]
* [http://www.mikrocontroller.net/topic/258652 Tutorial]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

STM32

2012-08-22T17:27:32Z

Mthomas: /* Tipp FPU von STM32F4xx nutzen */

STM32 ist ein Mikrocontroller-Familie von [http://www.st.com/mcu/inchtml-pages-stm32.html ST] mit einer 32-Bit [http://www.arm.com/products/processors/cortex-m/index.php ARM Cortex-M3/M4] CPU. Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt und löst damit die bisherigen ARM7-basierten Controller weitestgehend ab. Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrößen und -formen. Durch die geringe Chipfläche des Cores ist es ST möglich, eine 32 Bit-CPU für weniger als 1 € anzubieten.

[[Bild:stm32F103xc.png|thumb|right|340px|Blockdiagramm STM32F103xC/D/E]]

== STM32-Familien ==

Bisher gibt es sieben STM32-Familien:
* [http://www.st.com/internet/mcu/subclass/1588.jsp STM32F0]
** Cortex M0
** µC zum Einstieg
* [http://www.st.com/internet/mcu/subclass/1169.jsp STM32F1]
** Cortex M3
*** Connectivity line
*** Performance line
*** USB Access line
*** Access Line
*** Value line
* [http://www.st.com/internet/mcu/product/250173.jsp STM32F2]
** Cortex M3
** Wie die STM32F1 Serie, jedoch 120MHz, Camera-Interface, 32-Bit Timer, Crypto-Engine...
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3]
** ARM® Cortex™-M4-based STM32 F3, 72MHz
** DSP instructions and the floating point unit
** Fast 12-bit 5 MSPS and precise 16-bit sigma-delta ADCs
* [http://www.st.com/internet/mcu/subclass/1521.jsp STM32F4]
** Cortex M4
** ARM® Cortex™-M4-based STM32 F4, 168MHz
** DSP instructions and the floating point unit
* [http://www.st.com/mcu/inchtml-pages-stm32l.html STM32L]
** Cortex M3
** Low Power
** mit LCD Treiber
* [http://www.st.com/mcu/inchtml-pages-stm32w.html STM32W]
** Cortex M3
** RF-MCU
[http://www.st.com/internet/mcu/class/1734.jsp Hier eine Übersicht zum Auswählen eines STM32Fxxx]

'''Features'''
* Cortex-M3 bzw. Cortex-M4 Kern in der STM32F4xx Serie
* 16KB ... 1MB [[Flash-ROM]]
* 4KB ... 192KB [[Speicher#SRAM|SRAM]]
* 4KB [[Speicher#EEPROM|EEPROM]] (STM32L)
* 512 one-time programmable Bytes(STM32F2/4)
* [[IC-Gehäuseformen | Gehäuse]] 36 ... 176 Pins als QFN, LQFP und BGA
* Derzeit sind über '''250''' STM32 Derivate/Varianten verfügbar
* Bis 72MHz CPU-Takt, bis 120MHz beim STM32F2xx, bis 168 MHz beim STM32F4xx, wobei eine spezielle prefetch-hardware bis 120/168 MHz eine Geschwindigkeit erzielen soll, die 0 Wait-States entspricht. Der CPU-Takt wird über einen Multiplikator aus dem internen RC-Takt oder einem externen Quarz-Takt abgeleitet.
* Externes Businterface (nur bei Gehäusen ab 100 Pin und nur bei STM32F4, STM32F2 und STM32F1 Performance line)
* LCD Treiber für 8x40 Punkte (nicht beim STM32F2xx)
* Spannungsbereich 1,65 ... 3,6V, nur eine Betriebsspannung nötig
* Temperaturbereich bis 125 °C
* Bis zu 140 IOs, viele davon [[Pegelwandler|5V-tolerant]]
* Interner, kalibrierter RC-Oszillator mit 8MHz (16MHz bei STM32F2xx)
* Externer Quarz
* Real Time Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 16 [[Timer]], je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer (bei STM32F103xF/G)
* Systick Counter
* Bis zu 3 12-Bit [[AD-Wandler]] mit insgesamt 24 AD-Eingängen, integrierter [[Temperatursensor]], Referenzspannung Vrefint und VBatt Spannungsmessung (STM32F4xx)
* Bis zu 2 12-Bit [[DA-Wandler]]
* Bis zu 2 [[DMA]] Controller mit bis zu 12 Kanälen (16 beim STM32F2xx)
* Bis zu 2x [[I2C|I²C]]
* Bis zu 5x [[UART|USART]] mit LIN, IrDA und Modem Control (6 beim STM32F2xx)
* Bis zu 3x [[SPI]]
* Bis zu 2x [[I2S|I²S]]
* Bis zu 2x [[CAN]]
* Unique device ID register (96 Bits)
* RNG - Random Number Genrator (STM32F2xx)
* Cryptographic Processor (CRYP) (STM32F2xx)
* Hash Processor (HASH) (STM32F2xx)
* Kamera-Interface (DCMI) (STM32F2xx)
* [[USB]] 2.0 Full Speed / OTG
* [[USB]] 2.0 Hi Speed OTG mit extra PHY-Chip (STM32F2xx)
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich [[Ultra low power|Strom sparen]] lässt
* [[JTAG]] und SWD (Serial Wire Debug) Interface
* Bis zu 6 Hardware-Breakpoints für Debuggen
* und vieles mehr . . .

== Struktur der Dokumentation: ==

Als Beispiel der Dokumentation soll stellvertretend der [http://www.st.com/mcu/devicedocs-STM32F103RC-110.html STM32F103RC] genannt werden. Die Seite von ST beinhaltet alle nötigen Informationen passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00191185.pdf Datasheet STM32F103xC/D/E]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf Reference Manual (RM0008)]
* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/PROGRAMMING_MANUAL/CD00228163.pdf Cortex-M3 Programming Manual]
* [http://www.st.com/stonline/products/literature/pm/13259.pdf Flash Programming Reference]

Im Datasheet sind die speziellen Eigenschaften einer bestimmten Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für eine STM32-Familie. Details zum Prozessorkern selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich die Flash Programming Reference für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates. Hinzu kommen optionale Dokumente von ARM, die den [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337-/ Cortex-M3 Kern] / [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0439c/index.html Cortex-M4 Kern] beschreiben. Hier gibt es den Opcode wenn man ihn in [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0403-/ Assembler] programmieren möchte. Zusätzlich sollten auch die [http://www.st.com/stonline/products/literature/es/14732.pdf Errata Sheets] beachtet werden. Empfohlen sei auch die Appnote "[http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/APPLICATION_NOTE/CD00164185.pdf STM32F10xxx hardware development: getting started]".

== ‎STM32F10x Standard Peripherals Library ==

ST bietet eine umfangreiche Firmwarebibliothek, eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST (gibt es beispielsweise auf den Cortex-M3 Controllern von TI auch, ist teilweise in einem separaten ROM untergebracht). Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern. Diese Library und ihre Dokumentation setzen das grundlegende Verständnis der Funktion des jeweiligen Peripheriemoduls voraus, wie es die o.A. Referenz und diverse Appnotes vermitteln. Diese FW-Lib (Download von ST) ist ein MUSS für jeden, denn darin sind auch jede Menge Beispiele für alle Peripheriemodule.

Details siehe: [[‎STM32F10x Standard Peripherals Library]].

Mit [http://www.libopencm3.org/wiki/Main_Page libopencm3] ist derzeit auch eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library in Entwicklung, die zukünftig auch Cortex-M3 Controller von anderen Herstellern unterstützen soll.

== CMSIS ==

Parallel zur Firmware-Library (FW-Lib) gibt es für die "Selbermacher" die CMSIS (ARM® '''C'''ortex™ '''M'''icrocontroller '''S'''oftware '''I'''nterface '''S'''tandard), die grundsätzlich nur den herstellerübergreifenden ARM-Core abdeckt. Hierzu gehört bei den Cortex-M4-Cores auch die DSP und Floating-Point Funktionalität. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, den Sys-Tick-Counter, sowie eine SystemInit-Funktion, welche sich um die PLL kümmert.

Im Rahmen des CMSIS-Standards ([http://www.onARM.com www.onARM.com]) wurden die Headerdateien standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Die CMSIS C-Dateien bzw. Header enthalten auch Anpassungen für die verschiedenen Compiler. Die Portierung eines Real-Time-Betriebsystems sollte unter Verwendung der CMSIS, für Chips der verschiedenen Hersteller, stark vereinfacht möglich sein (z.B. einheitliche Adressen für Core-Hardware/Sys-Tick-Counter).

Die CMSIS ist im Download der FW-Lib enthalten. Die Compiler-Hersteller liefern eine jeweils zur ihrer Tool-Version passende bzw. geprüfte FW-Lib (incl. CMSIS) aus. Diese Libs können, gegenüber den Downloads beim Chip-Hersteller, auch ältere Version beinhalten.

== Debug- und Trace-Interface (CoreSight™ Debug and Trace Technologie)==

Übersicht über beide Funktionalitäten und den Schnittstellen:
http://www.keil.com/support/man/docs/ulink2/ulink2_cs_core_sight.htm

Die Coresight-Debug-Architektur ermöglicht ein nicht-invasives Debugging, d.h. es können während des Betriebes (meistens) ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Debugger Funktionen ===

Der Debugger-Teil besitzt drei Funktionen:
* Run Control: z.B. Programm-Start, Stopp und Einzel-Schritte.
* (Program) Break Points: Ein Programm hält an, wenn der Programm Counter eine bestimmte Programm-Adresse erreicht.
** Beinhaltet keine Data Watch Funktionalität, welche im Trace-Teil (DWT) realisiert wird.
* Memory Access: Lesen und Schreiben von Speicheradressen.
** Diese Funktionalität beinhaltet keine direkte Flash-Programmierung. Der Programmiervorgang für einen Flash ist herstellerspezifisch und muss von dem verwendeten Debugger unterstützt werden.

=== Trace Funktionen ===
Die Trace-Funktionalität wird in drei Funktionen aufgeteilt:
* ETM (Embedded Trace Macrocell): Optional, nicht jede CPU besitzt diese Hardware (Kostenfaktor, Austattung).
* ITM (Instrumentation Trace Macrocell): Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht werden, sowie "printf-ähnlich" Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.
* DWT (Data Watchpoint & Trace Unit):
** Data Watch: 4 Access-Break-Points ( z.B. der Debugger bleibt stehen, wenn das Programm auf einen Speicher zugreift oder der Wert einer Variablen einen bestimmten Wert annimmt).
** Trace Unit: Programmverlauf (durch Lesen des Program Counters) und Interrupt Aufrufe verfolgen, sowie Zeitmessungen.

Einige der Trace-Funktionalitäten können über die JTAG-Schnittstelle angesprochen werden. Die schnelle Trace-Funktionalität (mit 4 bit Parallel-Port) steht nur mit der erweiterten DEBUG + ETM Schnittstelle zur Verfügung. Im Gegensatz zum Debugger-Teil (Run Control, Break Points und Memory Access) werden Trace-Funktionen nicht von allen Debuggern unterstützt. Debugger mit der vollen Trace-Funktionalität kosten deutlich mehr.

* Beispiele für Trace-Port-Aktivierungen für verschiedene Hersteller: http://www.keil.com/support/man/docs/jlink/jlink_capture_tracedata.htm

Die Aktivierung des parallelen Trace-Ports erfordert, je nach CPU Hersteller, zusätzliche Debugger-Makros für die Aktivierung und Port-Freischaltung. Zusätzlich sind die Schnittstellenauswahl und Einstellung (Frequenzen) im Entwicklungs-Tool (IDE) wichtig, um erfolgreich den Programm-Verlauf "tracen" zu können.

=== Debug und Trace-Schnittstellen ===
Als Debug Interface stehen zwei Varianten zur Auswahl:
* [[JTAG]]: Dafür sind mindestens 6 Steuerleitungen nötig.
* SWD (Serial Wire Debug): Hier mindestens 2 Steuerleitungen (3 mit SWO, zzgl GND und 3,3V). Die SWD Schnittstelle ist in der Regel schneller und kann auch Funktionen aus dem Trace-Teil beinhalten (z.B. ITM, dafür wird der SWO-Pin benötigt).

Standard-JTAG Steckerbelegungen:
http://www.keil.com/support/man/docs/ulink2/ulink2_hw_connectors.htm

=== Der 10polige JTAG-Stecker von mmvisual ===
mmvisual hat mit dieser Steckerbelegung die Standard JTAG Schnittstelle erweitert:

Ich habe diesen Part in den Artikel [http://www.mikrocontroller.net/articles/JTAG#Der_10-Polige_JTAG_Stecker_von_mmvisual JTAG] verschoben.
Hinzu gekommen ist die Adapterplatine 10-Polig auf Standard JTAG 20 Polig mit TTL/V24 Wandler. [http://www.mikrocontroller.net/articles/JTAG#Die_Adapterplatine Siehe hier.]

=== STM32 RS232 (CAN und USB) Programmiertool ===

Auch ohne JTAG lässt sich ein STM32 programmieren (Bootloader-Aktivierung). Dabei stehen, je nach CPU-Typ, verschiedene Möglichkeiten zur Verfügung:
* RS-232 (bisher alle STMs)
* USB (nur in bestimmten MCUs mit entsprechender Bootloader-Version und PIN-Anzahl, z.B. STM32F105/107)
* CAN (wie USB nur in bestimmten MCUs)

3 zusätzliche Verbindungen müssen auf dem Board gepatcht werden. Für einen Test geht es auch mit Tastern für RESET und BOOT0. 
RESET=RTS (L-aktiv) 
BOOT0=DTR (H-aktiv) 
BOOT1=LOW 

Details sind hier im Forum: [http://www.mikrocontroller.net/topic/141711 STM32 Programmiertool]

== Vorteile ==

'''Vorteile gegenüber ARM7:'''

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vektortabelle, keine Sprungliste wie bei ARM7. Durch Automatismen zwischen Core und NVIC (auto register save r0..r3, lr, sp, pc) bei Interrupt Entry wird eine deutlich schnellere Ausführungszeit bei Interrupts erreicht. Der Interrupt Code muss sich nicht mehr selbst um die Sicherung der o.g. Register kümmern und eine besondere Konfiguration der Handler im Compiler entfällt. Sind vor Beendigung einer ISR (d.h. Rücksprung zum User Code) weitere Interrupts pending, so werden diese ausgeführt, ohne dass eine komplette pop-push-sequenz der Register notwendig ist. Schön beschrieben ist es hier im [http://www.st.com/mcu/files/mcu/1221142709.pdf Insider's Guide] unter 2.4.5 / Seite 20.
* Thumb-2 Befehlssatz, deutlich schneller als Thumb-1 und ebenso kompakt
* Weniger Pins für Debugging benötigt durch SWD
* Mehr Hardware Breakpoints machen debuggen einfacher
* Software ist einfacher weil die Umschaltung zwischen ARM Mode und Thumb Mode wegfällt

'''Vorteile gegenüber LPC1700 und LPC1300:'''

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* FW-Lib für alle STM32 gleich, alle AppNotes/Demos beziehen sich auf diese eine FW-Lib was die Entwicklung der eigenen Applikation sehr beschleunigt.
* Genauerer und flexiblerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010) Allerdings gibts den LPC1100 mit Cortex-M0 schon ab 0,65 $!
'''Nachteil gegenüber LPC1700:'''
* STM32F1xx: nur 72 MHz statt 100 MHz (LPC1759: 120 MHz) Taktfrequenz; STM32F2xx hat diesen Nachteil nicht (ebenfalls 120MHz, STM32F4xx mit 168MHz) (Aber NXP hat schon 150MHz angekündigt)
* Der LPC1700 besitzt deutlich mehr Mechanismen, um die Auswirkung der Waitstates des Flash-ROMs auf Code- und Datenzugriffe zu reduzieren und das bedeutet mehr Performance bei gleicher Taktfrequenz. Beim STM32F2 entfällt dieser Nachteil wohl aufgrund des ART accelerators.
* Alle LPC1xxx haben 32 Bit Timer. Bei den STM32 haben das nur die STM32F2xx (2 Stück)
* I2S Einheit von ST hat keinen FIFO und im 24/32Bit Modus müssen 2x16Bit Halbwörter übertragen werden.
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hobby-Anwender'''

* Nicht direkt "Steckbrettauglich", da kein DIL Gehäuse verfügbar. Der ebay-Shop dipmicro führt jedoch sehr günstige Lötadapter für Umsetzung von LQFP48 auf DIP48. QFP64 in 0.5mm Pinabstabd und nicht 0.8mm wie AVR

'''

== Hardware-Beschaltung ==

Der STM32 benötigt für den Betrieb nur (Minimalbeschaltung):

* VCC 2..3,3V (je nach Typ)
* AVCC 2..3,3V (sehr wichtig, der STM32 lässt sich ohne diese Spannung nicht programmieren)
* GND
* Reset Pin 100nF nach GND (ein Pull-Up Widerstand von ca. 40k ist intern vorhanden)
* Boot-Pins: Boot0 -> GND | Boot1 -> Egal ---> Mit der Konfiguration wird kein Bootloader gestartet

ansonsten nur ein paar einzelne Cs 100nF an VCC/GND.

Um Programmieren zu können wird entweder noch die serielle Schnittstelle (Programmieren über den vorprogrammierten Bootloader) oder JTAG oder die SWD Schnittstelle benötigt.

== Programmierung ==

Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden. Es ist für den Einsteiger schwierig herauszufinden welche Open-Source Programme man braucht damit es funktioniert, daher hier eine Zusammenstellung:

* [http://www.eclipse.org Eclipse]
* [http://www.yagarto.de Yagarto Tools] oder [http://www.codesourcery.com/sgpp/lite_edition.html Codesourcery Lite Edition] oder [https://launchpad.net/gcc-arm-embedded Launchpad]
* Programmieradapter OOCD, Turtelizer2 oder andere JTAG Programmieradapter
* Eclipse Plugin "GDB Hardware Debugging" mit [http://www.firefly-power.de/ARM/debugging.html OpenOCD server]
* [http://www.st.com/internet/com/software/ides_mcu.jsp#stm32 ST Liste: IDEs, Toolsets and Debug tools for MCUs]

* Zum Starten eine fertige Zusammenstellung: [http://www.mikrocontroller.net/topic/216554 Eclipse+codesourcery+st-link]

* [http://www.coocox.org/ Coocox Eclipse IDE] kostenlose IDE für Cortex M0/M3. Hilfreiche Infos gibt es im [http://www.mikrocontroller.net/topic/214719?goto=new#2228482 hier] und [http://www.mikrocontroller.net/topic/214719?goto=new#2229943 hier] Forum

* [http://www.mikrocontroller.net/topic/265600 STM32F4 mit Code::Blocks]

* [http://emide.org/ emIDE] kostenlose IDE die mit dem Segger J-LINK funktioniert.

Sehr nützlich für Linux-Anwender auch diese Seite: [http://fun-tech.se/stm32/index.php STM32/ARM Cortex-M3 HOWTO: Development under Ubuntu.]

Folgende kommerzielle Umgebungen sind verfügbar:

* [http://www.keil.com Keil µVision] (Demo max. 32KB Code): Die sehr komfortable µVison IDE ist neben dem ARM Compiler per Menue auch für einen beliebigen GNU-Compiler konfigurierbar. Damit besteht das 32k-Limit nur noch für den integrierten Debugger / Simulator. µVison selbst kann kostenlos mit dem MDK-Evaluationkit heruntergeladen werden.
* [http://www.iar.com IAR] (Demo max. 32KB Code)
* [http://www.raisonance.com Raisonance Ride7] (GCC Compiler, kostenlose Version auf Debugging von max. 32KB Code limitiert, keine Limitierung beim Complilieren)
* [http://www.atollic.com Atollic] (Lite Version (bis V2.3.0) ohne Code-Limit, auf GCC basierend. Die neueste Version ab V3 hat fast keine Beschränkungen mehr außer jetzt einen Code-Limit von 32kB. Außerdem werden jetzt die meisten ARM Familien unterstützt. )
* [http://www.coocox.org CoIDE] (Kostenlose GCC, Eclipse basierende IDE mit einem Code-Generator Tool)
* [http://www.rowley.co.uk/arm/ Rowley Crossworks] (Demo 30 Tage unbeschränkt, 150$ für nichtkommerzielle Nutzung, auf GCC basierend)
* [http://www.code-red-tech.com Code Red] (GCC basierend)

Programmieradapter
* [http://www.segger.com J-Link / J-Trace] Cortex-M3, als [http://www.segger.com/cms/j-link-edu.html NonComercial] J-Link für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* [http://olimex.com/dev/index.html Olimex] ARM-USB-OCD (ca. 60.-)
* Keil [http://www.keil.com/arm/ulink2/ ULINK2], [http://www.keil.com/arm/ulinkpro/ ULINK pro]
* [http://www.st.com/internet/evalboard/product/219866.jsp ST-LINK], [http://www.st.com/internet/evalboard/product/251168.jsp ST-LINK/V2]
*[http://www.st.com/internet/com/press_release/p3065.jsp STM32xx Discovery] jedes STM32 Discovery board hat einen ST-Link für Programmierung/Debugging per SWD on-board, welcher auch für eigene STM32 Target Hardware benutzt werden kann (ca. 12,- bis 19,-€, je nach Typ).
* [http://www.raisonance.com/~rlink-debugger-programmer__microcontrollers__tool~tool__T018:4cn9ziz4bnx6.html Raisonance RLink]
* [http://www.amontec.com Amontec]
* [http://www.hjtag.com H-JTAG] Personal Edition für ca. 60,- zu haben, läuft mit ADS, SDT, IAR, Vision und RVDS

Programmieradapter Open-Source
* [http://www.oocdlink.com/ OOCDLink]
* [https://github.com/texane/stlink Stlink]
* [http://www.randomprojects.org/wiki/Floss-JTAG FLOSS-JTAG]
* [http://capitanio.org/mlink/ Linux Demo Code für die Discovery's ST-Link Programmierung]

Der Controller hat auch einen fest eingebauten Boot-Lader. Damit läßt er sich auch über eine gewöhnliche serielle Schnittstelle programmieren, ohne daß man einen JTAG-Adapter benötigt.

Tipps für Installation mit Eclipse können in [http://www.mikrocontroller.net/topic/214719 diesem Thread] gelesen werden.

=== Installation für STM32 (Linux) ===

==== Variante A ====

* Benötigte Hardware
** Ein Desktop PC oder Laptop mit Linux OS (openSuSE, Ubuntu, ...) alternativ: Ein Windows System mit Linux in einer virtuellen Maschine
** root Zugang zum Linux OS (superuser Passwort)
** GNU C Compiler
** Programmer ARM-USB-TINY-H (optimal) alternativ: OpenOCD kompatiblen Programmer
** Prototypboard Olimex STM32-P107 (optimal) alternativ: irgendein board mit STM32 uC und JTAG Port

* Download + Installation (in einem Terminal)
wget http://hlb-labor.de/cortexm3/install_ToolChain_STM32.sh
chmod +x install_ToolChain_STM32.sh
./install_ToolChain_STM32.sh

Die Installation sollte im Idealfall voll automatisch durchlaufen. Anschliessend wird ein Beispielprojekt mit Multitasking OS und LED-Heartbeat kompiliert und auf den uC programmiert.
Für andere Protoboards/ Programmer muss die ToolChain entsprechend der readme Anleitung umkonfiguriert werden.

Das Projekt kann im QtCreator (http://qt.nokia.com/) geöffnet und bearbeitet werden.

==== Variante B ====

Die Installation einer Toolchain (Make, Flash, Debug via JTAG, IDE) ist in folgendem Manual beschrieben:

"How-to manual - Installing a toolchain for Cortex-M3/STM32 on Ubuntu 10.04"

*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.pdf
*http://www.seng.de/downloads/HowTo_ToolChain_STM32_Ubuntu.odt

Die Beschreibung im OpenOffice Format erlaubt die Weiterbearbeitung des Textes und das Entnehmen von Quelltexten ohne den Verlust von Formatierungen.

Verwendete Hardware:
*JTAG device
**Olimex “ARM-USB-OCD-H”, basierend auf FTDI “FT2232H”
*Microcontroller
**Olimex “STM32-H103” basierend auf STM32F103RBT6 mit 128KB Flash, 20KB RAM, 3xUART, ...
Die Toolchain sollte sich leicht an andere "FT2232" basierte JTAG Probes und "Cortex-M3" Derivate anpassen lassen.

Das Manual umfasst die Installation und Inbetriebnahme sowie Hinweise und Bug-fixes zu folgenden Komponenten:
*OpenOCD
*stm32flash
*Sourcery CodeBench Lite for ARM EABI
*STM32F10x standard peripheral library
*Project templates
*Makefiles
*Linker Sript
*Startup Code
*Doxygen
*Git
*Terminal emulation
*Eclipse IDE
*Links zu Datenblättern, Manuals und Toools

=== Installation für STM32 (Windows) ===

Hier ist der Anfang des Artikels [[STM32 Eclipse Installation]], hier ist neueres beschrieben als hier aufgeführt. Wenn der Artikel fertig ist, dann wird dieser Teil gelöscht.

* Eclipse "Helios" installieren mit GNU ARM Eclipse Plug-in
Eclipse IDE for C/C++ Developers<ref>http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliosr</ref> downloaden und installieren

* GNU ARM Eclipse Plug-in<ref>http://sourceforge.net/projects/gnuarmeclipse/</ref> runterladen und installieren. [http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page Weitere Infos].

Wird CodeSourcery G++ Lite verwendet, so muss die PATH Variable angepasst
werden, damit das Plugin die CodeSourcery exe-Files findet<ref>für Discovery notwendig</ref>. Alternativ das eclipse von einem script aus starten und zuerst den PATH erweitern.

Soll das ST-LINK verwendet werden, so kann der Atollic ST-LINK GDBSERVER aus der Atollic free version genutzt werden. Mit dem gdbserver im eclipse kann damit problemlos geflasht und gedebuggt werden (JTAG und SWD). Die Startup- und Linkerscripts der Atollic free version können für ein Projekt in dieser Konstallation genutzt werden.

* Eclipse "Galileo" installation<ref>[http://www.eclipse.org/] → Downloads → "Eclipse IDE for C/C++ Developers (79 MB)</ref>. Und das Servicepack 1<ref>[http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/SR1/eclipse-cpp-galileo-SR1-win32.zip Eclipse SR1]</ref>
Entpacken der Datei eclipse-cpp-galileo-SR1-win32.zip nach "C:\WinARM\" (Ordner neu erstellen)

* Eclipse PlugIn<ref>http://download.eclipse.org/tools/cdt/releases/galileo</ref> hinzufügen: Help → Install New Software... → "Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

* Yagarto Tools<ref>[http://www.yagarto.de/] "Download (for Windows)" → "YAGARTO Tools" http://www.yagarto.de/download/yagarto/yagarto-tools-20091223-setup.exe Installieren, Auswahl Verzeichnis "C:\WinARM\yagarto-tools"</ref>

* CodeSourcery: Achtung! Die Menustruktur ändert sich durchaus mal, dann suchen gehen. http://www.codesourcery.com/ → Products → Sourcery G++ → Editions>Lite Edition → ARM → Downloads. Direkter Download<ref>[http://www.codesourcery.com/sgpp/lite/arm/portal/package6496/public/arm-none-eabi/arm-2010q1-188-arm-none-eabi.exe]</ref>. Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD: Kompilierte Version für Windows<ref>[http://www.freddiechopin.info/] → Download → Software → OpenOCD</ref> installieren nach "C:\WinARM\OpenOCD_0_4_0" ist auch auf der Seite<ref>[http://yagarto.de/#ocd Yagarto.de]</ref> beschrieben. PS: Sollte der Olimex ARM-USB-OCD verwendet werden, dann darf nicht der Treiber von Olimex verwendet werden, sondern der vom OpenOCD Download<ref>[http://www.mikrocontroller.net/topic/173753#1668913]</ref>.

* ST Firmware: http://www.st.com → Auswahl CPU STM32F103xxx → "Firmware" "STM32F10x_StdPeriph_Lib"<ref>http://www.st.com/mcu/devicedocs-STM32F103RC-110.html</ref>. Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.4.0\

=== Installation für STM32 auf einem zweiten Rechner===

* Kopieren des Verzeichnisses C:\WinARM\ (Zuvor wurden aus diesem Grund alle Setup-Pakete nach C:\WinARM\... installiert)
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM\.... Verzeichnissen nachführen
* Fertig.

=== Installation für STM32 mit AtollicTrueStudio (+Demo) ===
* Installation + Demo: [[STM32 LEDBlinken AtollicTrueStudio]]

== Demo-Projekte ==

* [[prog_bsp_timer_1_timer2|Programmbeispiel für die Verwendung von Timer2 zusammen mit dem Interrupt]]
* [http://www.firefly-power.de/ARM/printf.html Printf() debugging mit minimalem Aufwand]
* [[STM32_BLDC_Control_with_HALL_Sensor|Programmbeispiel für BLDC Motoransteuerung (Timer 1) mit HALLSensor (Timer 3)]]
* [[Cortex_M3_OCM3U]]
* Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:
** [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html "ChaN's FAT-Module with STM32 SPI"]
* [[STM32 USB-FS-Device Lib]]
* Modellbau-Sender auf STM32-Basis mit vielen Treibern [http://www.rcos.eu www.rcos.eu]
* Ausführliches [https://github.com/jkerdels/stm32edu Einstiegs-Tutorial] in Codeform für das [http://www.st.com/internet/evalboard/product/252419.jsp STM32F4 discovery board]

== Errata, Tipps und Tricks ==

* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 9.3.3.: "CAN1 alternate function remapping". Alle Infos von RM0008 9.3.x sind interessant
* CAN und USB sind nur bei der "◦Connectivity-Line" gleichzeitig nutzbar. Siehe Datenblätter.
* Mit internem RC-Oszillator kann die CPU mit maximal 64MHz betrieben werden. Mit einem externen Quarz sind dann 72MHz möglich.
* Für USB Betrieb muss die CPU mit 48MHz oder 72MHz betrieben werden (bei STM32F1xx).
* Der Idle Interrupt vom Usart wird zwar ausgelöst, aber nicht vom entsprechenden Statusflag angezeigt
* Der DMA fängt beim aktivieren immer von vorn an zu zählen, auch wenn er nur kurz angehalten wurde
* STM32F2xx hat kein Flash Size Register, bei STM32F4xx ist zwar ein flash Size Register beschrieben, kollidiert aber in der Adresse mit einem anderen Register
* Derivate mit internem EEPROM und nur einer Speicherbank haben das "Feature" bei write/erase des Data-Flashes (EEPROM) einen kompletten stall der code execution zu verursachen (inkl. ISR's, DMA). Desgleichen bei write/erase des internen Flash (ISP-routinen, EEPROM-Emulation).

=== Tipps für Umsteiger von Atmel/PIC/8051 ===
* Prozessortakt hat unterschiedliche Taktquellen und eine PLL.
* Alle Peripheriemodule haben einen extra Clock, den man aktivieren muss.
* Wenn man z.B. einen UART benutzen möchte, so muss man den Clock vom UART, Alternate Function IO (AFIO) und dem GPIO-Port aktivieren.
* Ansonsten hat man nahezu doppelt so viele Möglichkeiten in den Peripheriemodulen.
* Interrupt-Flags müssen in der ISR selber gelöscht werden
* Forum zu [http://www.mikrocontroller.net/topic/175888 Interrupts vs. Events]

=== Tipp FPU von STM32F4xx nutzen ===
Es benötigt dafür 2 Dinge, zum einen muss die Compileroption gesetzt sein, zum anderen auch die FPU aktiviert werden:

Compileroption:

<code>COMMON_FLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16</code>

Der Code für das Aktivieren der FPU:

<c>/*FPU settings*/
__asm volatile ("ldr r0, =0xE000ED88"); /* Enable CP10,CP11 */
__asm volatile ("ldr r1,[r0]");
__asm volatile ("orr r1,r1,#(0xF << 20)");
__asm volatile ("str r1,[r0]");
</c>

Ohne Inline-Assembler in C wie in system_stm32f4xx.c aus den Beispielen von ST-Microelectronics:
<c>
SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
</c>

Mehr dazu in diesem Thread: [http://www.mikrocontroller.net/topic/261021 Floating Pointing Unit STM32F4]

=== Errata vom STM32F4xx die nicht im Errata von ST stehen ===
* [http://www.mikrocontroller.net/topic/267439#2788478 Aktivieren von DMA], wenn mehr als 3 DMA Kanäle aktiviert werden, kann es sein dass die nicht alle korrekt bedient werden. Auch klappt der DMA mit dem FSMC nicht immer zuverlässig. [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FWarning%20limit%20simultaneous%20DMAs%20to%202&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=811 siehe hier] [http://blog.frankvh.com/2012/01/13/stm32f2xx-stm32f4xx-dma-maximum-transactions/ und hier]
* [http://www.mikrocontroller.net/topic/260637#2700761 Nerviger Bug in "stm32f4xx.h"] Änderung Struktur GPIO_TypeDef
* [http://www.mikrocontroller.net/topic/261690#2714754 Batterie wird leer gezogen], nur bei manchen Chips mit Rev. A

== Bezugsquellen ==

=== Controller ===

Versandhäuser für Privatpersonen

* [http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html Darisus]
* [http://www.hbe-shop.de HBE (Farnell Programm für Private)]
* [http://www.sander-electronic.de/be00069.html Sander]
* [http://www.rs-online.com RS-Online]
*[http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+ TME]
* [https://www.distrelec.de/ishopWebFront/catalog/product.do/para/keywords/is/STM32_ARM-Microcontroller/and/language/is/de/and/shop/is/DE/and/series/is/1/and/id/is/01/and/node/is/34910.html Distrelec]

Gewerblich liefern natürlich viele wie Mouser, Farnell, Digikey usw...

=== Evaluation Boards ===

* [http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14 Im Shop von Embedded Projects]
* [http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3 Cortex M3 bei Watterott]
* [http://www.raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer und Primer2 von Raisonance]
* [http://www.sander-electronic.de/es0028.html Sander Electronic]
* [http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher Artikel im Wiki, ARM mit USB und 4MB Speicher]
* [http://www.futurlec.com/STM32_Development_Board.shtml Futurlec Evalboard, ebenso Header-Board]
* [http://www.propox.com/products/t_174.html Propox, Header-Boards für 103R und 103V sowie Trägerplatine dafür]
* [http://www.mikrocontroller.net/articles/Cortex_M3_OCM3U Cortex M3 Artikel im Wiki]
* [http://olimex.com/dev/index.html STM32 bei Olimex]
* [http://de.farnell.com/jsp/displayProduct.jsp?sku=1824325&action=view&CMP=GRHS-1000962 STM32Discovery bei Farnell] Mikrocontroller Board (STM32F100RBT6B) mit onboard USB-Programming Interface für ca. 12,50€
* [http://www.de.rs-online.com/web/p/products/7458434/ STM32Discovery bei RS-Components] 12,65 € +MwSt.
* [http://www.segor.de/#Q=STM32 VL DISCOVERY] STM32 Discovery bei Segor
* [http://www.watterott.com/de/STM32F4Discovery STM32F4DISCOVERY] STM32F4 Cortex M4 Controller mit JTAG-Debugger auf der Platine bei Watterott für 16,66EUR.
* [http://www.steitec.net/ARM-Boards/ Steitec, STM32F103 Cortex M3 Board 34,80€]
* [http://www.mcu-raisonance.com/~open4-development-platform__microcontrollers__tool~tool__T018:g65gu6ghg2n.html/ Open 4 oder auch genannt Evo-Primer]
* [http://www.wayengineer.com/index.php?main_page=index&cPath=50_66&page=1&sort=3a WayEngineer]

== Weblinks, Foren, Communities ==

* [http://www.mikrocontroller.net/topic/173753 Diskussion zum Artikel]
* [http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex* Suche im Forum]
* [https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx Forum auf der ST Homepage]
* [http://www.stm32circle.com/hom/index.php STM32 Community]
*[http://www.arm-forum.de Deutsches ARM-Forum]
*[http://joe-c.de/pages/posts/einstieg_mikrocontroller_stm32f103_101.php Einstieg: STM32board mit Kamera (deutsch)]
* [http://www.ebv.com/fileadmin/products/Press_Print/Brochures/Product_Brochures/EBV_Cortex%20Collection_V2.pdf Übersicht der Cortex Prozessoren und deren Hersteller (nicht nur ST, von EBV)]
* [http://www.mikrocontroller.net/topic/258652 Tutorial]

<references/>
[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

MMC- und SD-Karten

2012-08-03T16:08:30Z

Mthomas: OpenFAT dazu

MMC- und SD-Speicherkarten lassen sich im [[SPI]]-Modus relativ einfach mit einem Mikrocontroller ansteuern. Prinzipiell gibt es zwischen SD-Card und MMC nicht viele Unterschiede, allerdings sind SD-Karten weiter verbreitet, in der Regel schneller als MMCs, und haben ein besser implementiertes SPI-Interface. Es existieren diverse Varianten (miniSD, microSD), die zur normalen SD-Card weitgehend kompatibel sind.

Die Karte liest das anliegende Datenbit mit der steigenden Taktflanke ein, als SPI-Modi eignen sich somit Mode 0 (CPOL=0, CPHA=0) und Mode 3 (CPOL=1, CPHA=1) (siehe auch [[Serial Peripheral Interface]]). Bei MMCs ist der SPI-Modus nicht genau spezifiziert, somit kommt es durchaus mal vor dass der SPI-Modus je nach Karte unterschiedlich gewählt werden muss, oder dass die Karte überhaupt nicht zuverlässig funktioniert (siehe [http://www.mikrocontroller.net/forum/read-1-343528.html Beitrag im Forum]).

== DOs und DON'Ts bei der Ansteuerung ==

* '''Lasst euch nicht verrückt machen''' wenn es einfach nicht funktioniert, sondern probiert zu allererst mal eine SD-Karte eines anderen Herstellers aus. Die MMC-Implementierung für AVR von Elm Chan z. B. funktioniert mit SanDisk problemlos hat aber mit Platinum Karten ein Problem.
* Taktfrequenz bei der Initialisierung nicht höher als 400kHz
* Ein Pullup-Widerstand am Ausgang der MMC/SD Karte (DO) ist für eine saubere Initialisierung per SPI notwendig! [http://www.mikrocontroller.net/topic/112421#1001693 (Thread mit Erklärung dazu)]
* Saubere Versorgung: Kein Dioden-Pfusch, mit dem eine vorhandene 5V Versorgung mittels in Reihe geschalteter Dioden auf irgendwas im Bereich 3V "geregelt" wird. Stattdessen einen guten 3,3V-Regler verwenden. Die Karte mag es nicht, wenn mehr als 60mV Ripple auf Vcc ist. LM317 oder LM1117-ADC/-3.3 mit entspechenden Kondensatoren reicht zumindest bei Basteleien allemal.
* Sauberer Anschluss der Digitalschnittstelle: Spannungsteiler "verschleifen" die Signale bei hohen Frequenzen und die Übertragungsrate muss dann begrenzt werden. Also entweder ein [http://www.mikrocontroller.net/articles/Pegelwandler Pegelwandler] oder gleich an ein 3,3V I/O anschließen.
* Ein Pullup-Widerstand an der Select-Leitung (/CS) schadet nicht und stellt sicher, dass die Karte erst mit Absicht selektiert wird.
* Nachdem die Karte deselektiert wurde (/CS auf high), die Taktleitung noch einige Male pulsen, damit die Karte DO hochohmig/tri-state schaltet (vgl. Chans Erläuterungen).
* Die Karten verfügen weder über einen Reset- noch einen Sleep-Anschluss. Moderne Karten reduzieren bei Nichtbenutzung ihren Stromverbrauch, einen vollständigen Reset kann man jedoch nicht per Software auslösen. Daher sollten die Karten per P-Channel-FET oder Spannungsregler/-wandler mit Enable-Funktion so angeschlossen werden, dass über Versorgung an/aus ein (Power-On-)Reset ausgelöst werden kann. Dabei darauf achten, dass vorhandene Pull-Up-Widerstände bei abgeschalteter Versorgung ebenfalls deaktiviert werden (vgl. z. B. Schaltplan für den Anschluss von SD-Card/MMC per SPI an AVR in Chans Beispielen. Link unten).
* Guter Kontakt im Steckplatz, sehr gut eignen sich mit der Zange verbogene Stiftleisten, oft sieht es aus als ob es "passt", aber es gibt doch keinen Kontakt, daher bei Fehlern: Immer Durchmessen! Auch zu erwähnen wären da alte ISA-Bus Buchsen, die auf jedem alten PC Mainboard drauf sind. Um sicher zu gehen, dass der Kontakt wirklich gut ist, sollte man aber trotzdem SD-Slots benutzen. Diese bekommt man u.a. bei CSD (günstig), Reichelt (teuer) oder aus alten Kartenlesern.
* Guter Kontakt #2: Was sich im übrigen auch sehr gut eignet sind Adapter von MiniSD auf normales SD-Format, um dann MiniSD zu benutzen. Wenn man eine Stiftleiste im 2.54mm-Format oder Lötnägel im selben Format auf der Platine hat, kann man daran wunderbar den SD-Kartenadapter anlöten. Das ist mechanisch recht stabil. Ein kleines Manko ist allerdings, daß dann eine Gold-Lötzinn-Legierung durch die vergoldeten Kontakte entsteht und das soll ja dem Lötzinn langfristig nicht sehr zuträglich sein. Aber für's Hobby funktioniert das wunderbar.

{| border="0"
|-
||[[Bild:SD Steck Stift.jpg]] 
(Liefere Bild in besserer Qualität nach!)
|}

== Bibliotheken zur Ansteuerung ==

* [http://elm-chan.org/fsw/ff/00index_e.html ELM ChaN FatFs] FAT(12,16,32)-Dateisystem. Klein und übersichtlich, hochoptimiert, frei auch für kommerzielle Anwendung. Beispiele für AVR, H8, LPC2k mit MCI u.a. enthalten ("samples"), neuere Versionen mit LFN-Unterstützung. Beispiel für AT91SAM7 inkl. DMA im Projekt [[ARM MP3/AAC Player]]. (siehe auch [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/ M. Thomas' ARM+SD/MMC Seite])

* [http://elm-chan.org/fsw/ff/00index_p.html ELM ChaN Petit FatFS] FAT(12,16,32)-Dateisystem. Sehr klein. Beispiele für AVR.

* [http://sourceforge.net/projects/efsl EFSL] FAT16/32-Dateisystem, unterstützt Partitionen und Superfloppys, Beispielcode für AVR, LPC2000 und AT91SAM7 enthalten (siehe auch [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/ M. Thomas' ARM+SD/MMC Seite])

* [http://www.holger-klabunde.de/avr/avrboard.htm#cf Holger Klabundes FAT16/32] mit Beispielen für AVR MMC/SD und CF, LPC2k mit SPI

* libfat aus dem [http://sourceforge.net/projects/devkitpro devkitpro-Projekt] u.a. LFN-Unterstützung.

* [http://www.mikro-control.de/Joomla/index.php?option=com_content&task=view&id=18&Itemid=30 SD-Logger] - FAT 16, für den privaten Einsatz kostenfrei

* [http://www.mikrocontroller.net/forum/read-4-125350.html MMC-Ansteuerung mit FAT16 von Ulrich Radig]

* [http://www.zws.com/products/dosfs/index.html DOSFS Free FAT12/FAT16/FAT32 Filesystem] "DOSFS is a free FAT-compatible filesystem intended for fairly low-end embedded applications. Intended target systems would be in the ballpark of 1K RAM, 4K ROM or more".

* [http://www.mikrocontroller.net/topic/48481 MMC/SD-Karte mit FAT16 an AVR] von Roland Riegel

* [ftp://ftp.circuitcellar.com/pub/Circuit_Cellar/2005/176/Sham176.zip Circuit Cellar FAT16 MMC/SD] mit MMC/SD Hardwaretreiber für MSP430

* [http://www.analog.com "Implementing FAT32 File Systems on ADSP-BF533 Blackfin Processors"] Application Note und Code von ADI

* [http://www.atmel.com/dyn/products/tools.asp?family_id=682 FAT-Code in Atmel's AVR32 UC3 Software-Library]

* [http://www.mikrocontroller.net/articles/FAT32 AVR FAT16/32] Bibliothek mit Wiki. Unterstützt LFN und Ordner Rekursiv löschen. SVN für neuste Version.

* [http://www.embedded-os.de/index.html?pcfat_port.htm pC/FAT driver] "using SPI for sector read/write to MMC/MMCplus/HD-MMC/M-Bridge/SD/SDHC-cards on different platforms"

* [http://www.dharmanitech.com/2009/01/sd-card-interfacing-with-atmega8-fat32.html SD Card Interfacing with ATmega8] (FAT32 implementation) by CC Dharmani

* [http://www.blacksphere.co.nz/main/openfat OpenFAT]: "OpenFAT is a FAT filesystem implementation intended for use with embedded microcontrollers in small systems. (...) OpenFAT is licensed under the GPL, version 3."

== Allgemeine Informationen ==

* [http://www.digitalspirit.org/file/index.php/obj/docs/sd/ Datenblätter] ( [http://www.digitalspirit.org/file/index.php/obj-download/docs/sd/ProductManualSDCardv2.2final.pdf SD Card Product Manual 2.2] )

* [http://elm-chan.org/docs/mmc/mmc_e.html ELM ChaN - How to Use an MMC]

* [http://elm-chan.org/fsw/ff/00index_e.html ELM ChaN - FatFs Generic FAT File System Module]

* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=MMC*+SD Beiträge zum Thema MMC/SD im Forum (ca. 200 Threads)]

* [http://www.shop.display3000.com/elektronikmodule/sd-speicherkartenplatine.html Weiter unten im Text (runterscrollen) gibt es interessante Oszi-Bilder zu den oft genannten Spannungsteilern oder Transistorlösungen als Pegelwandler]

* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en547784 Microchip Memory Disk Drive System mit FAT32 und SDHC Unterstützung]

* [http://www.ifas.htwk-leipzig.de/easytoweb/download/D&E_11_2006_Anbindung_von_SD-Karten.pdf Gute Beschreibung der SDIO-Architektur und wie man eine SD-Karte mit ARM bzw. AVR benutzt]

== Bauteile ==

* [http://www.instructables.com/id/EZD6Q18LYGES1762SJ/ DIY SD-Card Fassung aus einem alten Floppy Kabel]

* [http://www.watterott.com/index.php?page=search&page_action=query&desc=on&sdesc=on&keywords=multicomp&x=0&y=0 Halter für SD-Karten]

* [http://www.shop.display3000.com/elektronikmodule/sd-speicherkartenplatine.html günstige Komplettlösung mit bidirektionalem Pegelwandler, Spannungsregler, Kartenhalter]

== Projekte ==

* [http://retromaster.wordpress.com/ufe/ Ultimate Floppy Emulator] von Retromaster (PIC32 @ 80 Mhz, 16 Mb SDRAM)

[[Category:Bauteile]]
[[Category:Datenübertragung]]
[[Kategorie:Speicher und Dateisysteme]]

Kategorie:Boards

2012-05-28T06:48:04Z

Mthomas: Änderungen von 58.23.208.70 (Diskussion) rückgängig gemacht und letzte Version von Doschi wiederhergestellt

[[Kategorie:!Hauptkategorie]]

Benutzer:Mthomas

2012-05-03T09:12:42Z

Mthomas:

* http://www.siwawi.arubi.uni-kl.de/avr_projects/
* http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/

Benutzer:Mthomas

2012-05-03T09:12:24Z

Mthomas: Hob den Schutz von „Benutzer:Mthomas“ auf

* http://www.siwawi.arubi.uni-kl.de/avr_projects/
* http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/

:{| {{Tabelle}}
|-
| 1
| 2
|-
|}

Benutzer:Mthomas

2012-05-03T01:40:54Z

Mthomas: Schützte „Benutzer:Mthomas“: Weblink-Spam: Vorlage:Tabelle im Text genutzt - versuch Kaskadenschutz ([edit=sysop] (bis 3. November 2012, 02:40 Uhr (UTC)) [move=sysop] (bis 3. November 2012, 02:40 Uhr (UTC))) [kaskadierend]

* http://www.siwawi.arubi.uni-kl.de/avr_projects/
* http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/

:{| {{Tabelle}}
|-
| 1
| 2
|-
|}

Benutzer:Mthomas

2012-05-03T01:39:22Z

Mthomas:

* http://www.siwawi.arubi.uni-kl.de/avr_projects/
* http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/

:{| {{Tabelle}}
|-
| 1
| 2
|-
|}

Vorlage:Tabelle

2012-05-03T01:32:24Z

Mthomas: Schützte „Vorlage:Tabelle“ ([edit=sysop] (bis 3. Mai 2013, 01:32 Uhr (UTC)) [move=sysop] (bis 3. Mai 2013, 01:32 Uhr (UTC)))

border="1" cellpadding="4" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #AAA solid; border-collapse: collapse; empty-cells:show; {{{1}}} }"

AVR-GCC-Tutorial

2012-04-23T19:31:42Z

Mthomas: /* Programmieren mit Interrupts */

= Voraussetzungen =

Vorausgesetzt werden Grundkenntnisse der Programmiersprache C. Diese Kenntnisse kann man sich online erarbeiten, z. B. mit dem [http://www.schellong.de/c.htm C Tutorial von Helmut Schellong] ([[C|Liste von C-Tutorials]]). Nicht erforderlich sind Vorkenntnisse in der Programmierung von Mikrocontrollern, weder in Assembler noch in einer anderen Sprache.

= Vorwort =

Dieses Tutorial soll den Einstieg in die Programmierung von Atmel [[AVR]]-Mikrocontrollern in der Programmiersprache [[C]] mit dem freien C-Compiler [[AVR-GCC]] aus der [http://gcc.gnu.org/ GNU Compiler Collection] erleichtern.

In diesem Text wird häufig auf die Standardbibliothek avr-libc verwiesen, für die es eine [http://www.nongnu.org/avr-libc/user-manual/index.html Online-Dokumentation] gibt, in der sich auch viele nützliche Informationen zum Compiler und zur Programmierung von AVR Controllern finden (beim Paket WinAVR gehört die avr-libc Dokumentation zum Lieferumfang und wird mitinstalliert).

Der Compiler und die Standardbibliothek avr-libc werden stetig weiterentwickelt. Einige Unterschiede, die sich im Verlauf der Entwicklung ergeben haben, werden im Haupttext und Anhang zwar erläutert, Anfängern sei jedoch empfohlen, die aktuellen Versionen zu nutzen (für MS-Windows: aktuelle Version des [[WinAVR]]-Pakets; für Linux: siehe Artikel [[AVR und Linux]]).

Das ursprüngliche Tutorial stammt von Christian Schifferle, viele neue Abschnitte und aktuelle Anpassungen von Martin Thomas.

Dieses Tutorial ist in PDF-Form hier erhältlich (nicht immer auf aktuellem Stand):
[[Media:AVR-GCC-Tutorial.pdf]]

== Weiterführende Kapitel ==

Um dieses riesige Tutorial etwas überschaubarer zu gestalten, wurden einige Kapitel ausgelagert, die nicht unmittelbar mit den Grundlagen von avr-gcc in Verbindung stehen. All diese Seiten gehören zur [[:Kategorie:avr-gcc Tutorial]].
: → [[AVR-GCC-Tutorial/Der UART|Der UART]]
: → [[AVR-GCC-Tutorial/Analoge Ein- und Ausgabe|Analoge Ein- und Ausgabe]]
: → [[AVR-GCC-Tutorial/Der Watchdog|Der Watchdog]]
: → [[AVR-GCC-Tutorial/Die Timer und Zähler des AVR|Die Timer und Zähler des AVR]]
: → [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]]
: → [[AVR-GCC-Tutorial/LCD-Ansteuerung|LCD-Ansteuerung]]
: → [[AVR-GCC-Tutorial/Alte Quellen|Alte Quellen anpassen]]
: → [[AVR-GCC-Tutorial/Assembler und Inline-Assembler|Assembler und Inline-Assembler]]

= Benötigte Werkzeuge =

Um eigene Programme für AVRs mittels avr-gcc/avr-libc zu erstellen und zu testen, wird folgende Hard- und Software benötigt:

* Platine oder Versuchsaufbau für die Aufnahme eines AVR Controllers, der vom avr-gcc Compiler unterstützt wird (alle ATmegas und die meisten AT90, siehe Dokumentation der avr-libc für unterstützte Typen). Dieses Testboard kann durchaus auch selbst gelötet oder auf einem Steckbrett aufgebaut werden. Einige Registerbeschreibungen dieses Tutorials beziehen sich auf den inzwischen veralteten AT90S2313. Der weitaus größte Teil des Textes ist aber für alle Controller der AVR-Familie gültig. Brauchbare Testplattformen sind auch das [[STK500]] und der [[AVR Butterfly]] von Atmel. Weitere Infos findet man in den Artikeln [[AVR#Starterkits|AVR Starterkits]] und [[AVR-Tutorial: Equipment]].

* Der avr-gcc Compiler und die avr-libc. Kostenlos erhältlich für nahezu alle Plattformen und Betriebssysteme. Für MS-Windows im Paket [[WinAVR]]; für Unix/Linux siehe auch Hinweise im Artikel [[AVR-GCC]] und im Artikel [[AVR und Linux]].

* Programmiersoftware und -[[AVR In System Programmer |hardware]] z. B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], Atmel AVRISP, [[AVR-Studio]]).

* Nicht unbedingt erforderlich, aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]]).

* Wer unter Windows und Linux gleichermassen entwickeln will, der sollte sich die [http://www.eclipse.org/ IDE Eclipse for C/C++ Developers] und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin ] ansehen, beide sind unter Windows und Linux einfach zu installieren. Hier gibt es auch einen [[AVR_Eclipse|Artikel AVR Eclipse]] in dieser Wiki. Ebenfalls unter Linux und Windows verfügbar ist die Entwicklungsumgebung [http://www.codeblocks.org/ Code::Blocks] (aktuelle, stabile Versionen sind als Nightly Builds regelmäßig im [http://forums.codeblocks.org/ Forum] verfügbar). Innerhalb dieser Entwicklungsumgebung können ohne die Installation zusätzlicher Plugins "AVR-Projekte" angelegt werden. Für Linux gibt es auch noch das [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=25220&postdays=0&postorder=asc&start=0 KontrollerLab].

= Was tun, wenn's nicht klappt? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder nur die eigenen C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.

* Die [[AVR Checkliste]] durcharbeiten.

* Die '''[http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc]''' lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/'''Frequently Asked Questions''' = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.

* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.

* Das [http://www.mikrocontroller.net/forum/gcc GCC-Forum auf www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.

* Das avr-gcc-Forum bei [http://www.avrfreaks.net AVRfreaks] nach vergleichbaren Problemen absuchen.

* Das [http://lists.gnu.org/archive/html/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.

* Nach Beispielcode suchen. Vor allem im ''Projects''-Bereich von [http://www.avrfreaks.net AVRfreaks] (anmelden).

* Google oder yahoo befragen schadet nie.

* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal). Datenblätter sind auf den [http://www.atmel.com Atmel Webseiten] als pdf-Dateien verfügbar. Das komplette Datenblatt (complete) und nicht die Kurzfassung (summary) verwenden.

* Die Beispielprogramme im [[AVR-Tutorial]] sind zwar in AVR-Assembler verfasst, Erläuterungen und Vorgehensweisen sind aber auch auf C-Programme übertragbar.

* Einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei möglichst viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode oder besser ein [http://www.mikrocontroller.net/topic/72767#598986 Testprojekt] mit allen notwendigen Dateien, um das Problem nachzuvollziehen, sowie genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z. B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: '''[http://www.tty1.net/smart-questions_de.html "Wie man Fragen richtig stellt"]'''.

= Erzeugen von Maschinencode =

Aus dem C-Quellcode erzeugt der avr-gcc Compiler (zusammen mit Hilfsprogrammen wie z. B. Präprozessor, Assembler und Linker) Maschinencode für den AVR-Controller. Üblicherweise liegt dieser Code dann im Intel Hex-Format vor ("Hex-Datei"). Die Programmiersoftware (z. B. [[AVRDUDE]], PonyProg oder AVRStudio/STK500-plugin) liest diese Datei ein und überträgt die enthaltene Information (den Maschinencode) in den Speicher des Controllers. Im Prinzip sind also "nur" der avr-gcc-Compiler (und wenige Hilfsprogramme) mit den "richtigen" Optionen aufzurufen, um aus C-Code eine "Hex-Datei" zu erzeugen. Grundsätzlich stehen dazu zwei verschiedene Ansätze zur Verfügung:

* Die Verwendung einer integrierten Entwicklungsumgebung (IDE = '''I'''ntegrated '''D'''evelopment '''E'''nvironment), bei der alle Einstellungen z. B. in Dialogboxen durchgeführt werden können. Unter Anderem kann AVRStudio ab Version 4.12 (kostenlos auf [http://www.atmel.com/ atmel.com]) zusammen mit WinAVR als integrierte Entwicklungsumgebung für den Compiler avr-gcc genutzt werden (dazu müssen AVRStudio und WinAVR auf dem Rechner installiert sein). Weitere IDEs (ohne Anspruch auf Vollständigkeit): [http://www.eclipse.org/ Eclipse for C/C++ Developers] (d.h. inkl. CDT) und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin] (für diverse Plattformen, u.a. Linux und MS Windows, IDE und Plugin kostenlos), [http://sourceforge.net/projects/kontrollerlab KontrollerLab] (Linux/KDE, kostenlos). [http://www.atmanecl.com/EnglishSite/SoftwareEnglish.htm AtmanAvr] (MS Windows, relativ günstig), KamAVR (MS-Windows, kostenlos, wird augenscheinlich nicht mehr weiterentwickelt), [http://www.amctools.com/vmlab.htm VMLab] (MS Windows, ab Version 3.12 ebenfalls kostenlos). Integrierte Entwicklungsumgebungen unterscheiden sich stark in Ihrer Bedienung und stehen auch nicht für alle Plattformen zur Verfügung, auf denen der Compiler ausführbar ist (z. B. AVRStudio nur für MS-Windows). Zur Anwendung des avr-gcc Compilers mit IDEs sei hier auf deren Dokumentation verwiesen.

* Die Nutzung des Programms make mit passenden Makefiles. In den folgenden Abschnitten wird die Generierung von Maschinencode für einen AVR ("hex-Datei") aus C-Quellcode ("c-Dateien") anhand von "make" und den "Makefiles" näher erläutert. Viele der darin beschriebenen Optionen findet man auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio (AVRStudio generiert ein makefile in einem Unterverzeichnis des Projektverzeichnisses).

Beim Wechsel vom makefile-Ansatz nach WinAVR-Vorlage zu AVRStudio ist darauf zu achten, dass AVRStudio (Stand: AVRStudio Version 4.13) bei einem neuen Projekt die Optimierungsoption (vgl. Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|AVR-GCC-Tutorial/Exkurs: Makefiles]], typisch: -Os) nicht einstellt und die mathematische Bibliothek der avr-libc (libm.a, Linker-Option -lm) nicht einbindet. (Hinweis: Bei Version 4.16 wird beides bereits gesetzt). Beides ist Standard bei Verwendung von makefiles nach WinAVR-Vorlage und sollte daher auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio "manuell" eingestellt werden, um auch mit AVRStudio kompakten Code zu erzeugen.

= Einführungsbeispiel =

Zum Einstieg ein kleines Beispiel, an dem die Nutzung des Compilers und der Hilfsprogramme (der sogenannten ''Toolchain'') demonstriert wird. Detaillierte Erläuterungen folgen in den weiteren Abschnitten dieses Tutorials.

Das Programm soll auf einem AVR Mikrocontroller einige Ausgänge ein- und andere ausschalten. Das Beispiel ist für einen ATmega16 programmiert ([http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf Datenblatt]), kann aber sinngemäß für andere Controller der AVR-Familie modifiziert werden.

Ein kurzes Wort zur Hardware: Bei diesem Programm werden alle Pins von PORTB auf Ausgang gesetzt, und einige davon werden auf HIGH andere auf LOW gesetzt. Das kann je nach angeschlossener Hardware an diesen Pins kritisch sein. Am ungefährlichsten ist es, wenn nichts an den Pins angeschlossen ist und man die Funktion des Programmes durch eine Spannungsmessung mit einem Multimeter kontrolliert. Die Spannung wird dabei zwischen GND-Pin und den einzelnen Pins von PORTB gemessen.

Zunächst der Quellcode der Anwendung, der in einer Text-Datei mit dem Namen ''main.c'' abgespeichert wird.

<c>
/* Alle Zeichen zwischen Schrägstrich-Stern
und Stern-Schrägstrich sind Kommentare */

// Zeilenkommentare sind ebenfalls möglich
// alle auf die beiden Schrägstriche folgenden
// Zeichen einer Zeile sind Kommentar

#include <avr/io.h> // (1)

int main (void) { // (2)

DDRB = 0xFF; // (3)
PORTB = 0x03; // (4)

while(1) { // (5)
/* "leere" Schleife*/ // (6)
} // (7)

/* wird nie erreicht */
return 0; // (8)
}
</c>

# In dieser Zeile wird eine sogenannte Header-Datei eingebunden. In <code>avr/io.h</code> sind die Registernamen definiert, die im späteren Verlauf genutzt werden. Auch unter Windows wird ein <code>/</code> zur Kennzeichnung von Unterverzeichnissen in Include-Dateinamen verwendet und kein <code>\</code>.
# Hier beginnt das eigentliche Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion <code>main</code>.
# Die Anschlüsse eines AVR (Pins) werden zu Blöcken zusammengefasst, einen solchen Block bezeichnet man als Port. Beim ATmega16 hat jeder Port 8 Anschlüsse, bei kleineren AVRs können einem Port auch weniger als 8 Anschlüsse zugeordnet sein. Da per Definition (Datenblatt) alle gesetzten Bits in einem Datenrichtungsregister den entsprechenden Anschluss auf Ausgang schalten, werden mit DDRB=0xff alle Anschlüsse des Ports B als Ausgänge eingestellt.
# Die den ersten beiden Bits des Ports zugeordneten Anschlüsse (PB0 und PB1) werden 1, alle anderen Anschlüsse des Ports B (PB2-PB7) zu 0. Aktivierte Ausgänge (logisch 1 oder "high") liegen auf Betriebsspannung (VCC, meist 5 Volt), nicht aktivierte Ausgänge führen 0 Volt (GND, Bezugspotential). Es ist sinnvoll, sich möglichst frühzeitig eine alternative Schreibweise beizubringen, die wegen der leichteren Überprüfbarkeit und Portierbarkeit oft im weiteren Tutorial und in Forenbeiträgen benutzt wird. Die Zuordnung sieht in diesem Fall so aus, Näheres dazu im Artikel [[Bitmanipulation]]:<c>PORTB = (1<<PB1) | (1<<PB0);</c>
# ist der Beginn der sogenannte ''Hauptschleife'' (main-loop). Dies ist eine Endlosschleife, welche kontinuierlich wiederkehrende Befehle enthält.
# In diesem Beispiel ist die Hauptschleife leer. Der Controller durchläuft die Schleife immer wieder, ohne dass etwas passiert. Eine solche Schleife ist notwendig, da es auf dem Controller kein Betriebssystem gibt, das nach Beendigung des Programmes die Kontrolle übernehmen könnte. Ohne diese Schleife kehrt das Programm aus <code>main</code> zurück, alle Interrupts werden deaktiviert und eine Endlosschleife betreten.
# Ende der Hauptschleife und Sprung zur passenden, öffnenden Klammer, also zu 5.
# ist das Programmende. Die Zeile ist nur aus Gründen der C-Kompatibilität enthalten: <c>int main(void)</c> besagt, dass die Funktion einen int-Wert zurückgibt. Die Anweisung wird aber nicht erreicht, da das Programm die Hauptschleife nie verlässt.

Um diesen Quellcode in ein lauffähiges Programm zu übersetzen, wird hier ein Makefile genutzt. Das verwendete Makefile findet sich auf der Seite [[Beispiel Makefile]] und basiert auf der Vorlage, die in WinAVR mitgeliefert wird und wurde bereits angepasst (Controllertyp ATmega16). Man kann das Makefile bearbeiten und an andere Controller anpassen oder sich mit dem Programm MFile menügesteuert ein Makefile "zusammenklicken". Das Makefile speichert man unter dem Namen <code>Makefile</code> (ohne Endung) im selben Verzeichnis, in dem auch die Datei <code>main.c</code> mit dem Programmcode abgelegt ist. Detailliertere Erklärungen zur Funktion von Makefiles finden sich im Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]].

<pre>
D:\beispiel>dir

Verzeichnis von D:\beispiel

28.11.2006 22:53 <DIR> .
28.11.2006 22:53 <DIR> ..
28.11.2006 20:06 118 main.c
28.11.2006 20:03 16.810 Makefile
2 Datei(en) 16.928 Bytes
</pre>

Nun gibt man ''make all'' ein. Falls das mit WinAVR installierte Programmers Notepad genutzt wird, gibt es dazu einen Menüpunkt im Tools Menü. Sind alle Einstellungen korrekt, entsteht eine Datei <code>main.hex</code>, in welcher der Code für den AVR enthalten ist.
<pre>
D:\beispiel>make all

-------- begin --------
avr-gcc (GCC) 3.4.6
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Compiling C: main.c
avr-gcc -c -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -f
unsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef
-Wa,-adhlns=obj/main.lst -std=gnu99 -Wundef -MD -MP -MF .dep/main.o.d main.c -
o obj/main.o

Linking: main.elf
avr-gcc -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -funs
igned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef -W
a,-adhlns=obj/main.o -std=gnu99 -Wundef -MD -MP -MF .dep/main.elf.d obj/main.o
--output main.elf -Wl,-Map=main.map,--cref -lm

Creating load file for Flash: main.hex
avr-objcopy -O ihex -R .eeprom main.elf main.hex
</pre>

Der Inhalt der hex-Datei kann nun zum Controller übertragen werden. Dies kann z. B. über In-System-Programming ([[ISP]]) erfolgen, das im [[AVR-Tutorial: Equipment]] beschrieben ist. Makefiles nach der WinAVR/MFile-Vorlage sind für die Nutzung des Programms [[AVRDUDE]] vorbereitet. Wenn man den Typ und Anschluss des Programmiergerätes richtig eingestellt hat, kann mit ''make program'' die Übertragung mittels AVRDUDE gestartet werden. Jede andere Software, die hex-Dateien lesen und zu einem AVR übertragen kann<ref>z. B. [[Pony-Prog_Tutorial|Ponyprog]], yapp, AVRStudio</ref>, kann natürlich ebenfalls genutzt werden.

Startet man nun den Controller (Reset-Taster oder Stromzufuhr aus/an), werden vom Programm die Anschlüsse PB0 und PB1 auf 1 gesetzt. Man kann mit einem Messgerät nun an diesem Anschluss die Betriebsspannung messen oder eine [[LED]] leuchten lassen (Anode an den Pin, Vorwiderstand nicht vergessen). An den Anschlüssen PB2-PB7 misst man 0 Volt. Eine mit der Anode mit einem dieser Anschlüsse verbundene LED leuchtet nicht.

= Ganzzahlige Datentypen (Integer) =

Bei der Programmierung von Mikrokontrollern ist die Definition einiger ganzzahliger Datentypen sinnvoll, an denen eindeutig die Bit-Länge abgelesen werden kann.

Standardisierte Datentypen werden in der Header-Datei <code>stdint.h</code> definiert, die folgendermaßen eingebunden werden kann:
<c>#include <stdint.h></c>

{| {{Tabelle}}
|+ '''int-Typen aus <code>stdint.h</code> (C99)'''  
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenbehaftete int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>int8_t</code> ||align="right"| 8 || −128 ⋯ 127 || −27 ⋯ 27−1 || <code>signed char</code>
|-
|<code>int16_t</code> ||align="right"| 16 || −32768 ⋯ 32767 || −215 ⋯ 215−1 || <code>signed short</code>, <code>signed int</code>
|-
|<code>int32_t</code> ||align="right"| 32 || −2147483648 ⋯ 2147483647 || −231 ⋯ 231−1 || <code>signed long</code>
|-
|<code>int64_t</code> ||align="right"| 64 || −9223372036854775808 ⋯ 9223372036854775807 || −263 ⋯ 263−1 || <code>signed long long</code>
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenlose int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>uint8_t</code> ||align="right"| 8 || 0 ⋯ 255 || 0 ⋯ 28−1 || <code>unsigned char</code>
|-
|<code>uint16_t</code> ||align="right"| 16 || 0 ⋯ 65535 || 0 ⋯ 216−1 || <code>unsigned short</code>, <code>unsigned int</code>
|-
|<code>uint32_t</code> ||align="right"| 32 || 0 ⋯ 4294967295 || 0 ⋯ 232−1 || <code>unsigned long</code>
|-
|<code>uint64_t</code> ||align="right"| 64 || 0 ⋯ 18446744073709551615 || 0 ⋯ 264−1 || <code>unsigned long long</code>
|}

Neben den Typen gibt es auch Makros für die Bereichsgrenzen wie <code>INT8_MIN</code> oder <code>UINT16_MAX</code>. Siehe dazu auch: [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdint.html Dokumentation der avr-libc: Standard Integer Types].

= Bitfelder =

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bits breit ist.

Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in eine einzelne Bytevariable zusammenfassen und (fast) wie
8 einzelne Variablen ansprechen können. Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<c>
struct {
unsigned bStatus_1:1; // 1 Bit für bStatus_1
unsigned bStatus_2:1; // 1 Bit für bStatus_2
unsigned bNochNBit:1; // Und hier noch mal ein Bit
unsigned b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</c>

Der Zugriff auf ein solches Feld erfolgt nun, wie beim Strukturzugriff bekannt,
über den Punkt- oder den Dereferenzierungs-Operator:

<c>
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</c>

Bitfelder sparen Platz im RAM, zu Lasten von Platz im Flash, verschlechtern aber unter Umständen die Les- und Wartbarkeit des Codes. Anfängern wird deshalb geraten, ein "ganzes" Byte (uint8_t) zu nutzen, auch wenn nur ein Bitwert gespeichert werden soll.

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

[[Image:Sequentielle Programme.gif|left]]
Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat. Es wird hier nach dem sogenannten EVA-Prinzip gehandelt. EVA steht für "Eingabe, Verarbeitung, Ausgabe".
{{Absatz}}

== Interruptgesteuerter Programmablauf ==

[[Image:Interrupt Programme.gif|left]]
Bei dieser Methode werden beim Programmstart zuerst die gewünschten Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher Dinge erledigt werden können, welche nicht zeitkritisch sind. Wenn ein Interrupt ausgelöst wird, so wird automatisch die zugeordnete Interruptfunktion ausgeführt.
{{Absatz}}

= Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heißt, das Programm kann die
Inhalte der Register sowohl auslesen als auch beschreiben.

Register haben einen besonderen Stellenwert bei den AVR Controllern. Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir die 8-Bit Register.

Einzelne Register sind bei allen AVRs vorhanden, andere wiederum nur bei bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff auf den UART notwendig sind, selbstverständlich nur bei denjenigen Modellen vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden AVR-Typen definiert. Dazu muss man den Namen der controllerspezifischen Headerdatei nicht kennen. Es reicht aus, die allgemeine Headerdatei ''avr/io.h'' einzubinden:

<c>
#include <avr/io.h>
</c>

Ist im Makefile der MCU-Typ z. B. mit dem Inhalt atmega8 definiert (und wird somit per -mmcu=atmega8 an den Compiler übergeben), wird beim Einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit den Register-Definitionen für den ATmega8 eingelesen.


Intern wird diese "Automatik" wie folgt realisiert: Der Controllertyp wird dem Compiler als Parameter übergeben (vgl. ''avr-gcc -c -mmcu=atmega16 [...]'' im Einführungsbeispiel). Wird ein Makefile nach der WinAVR/mfile-Vorlage verwendet, setzt man die Variable ''MCU'', der Inhalt dieser Variable wird dann an passender Stelle für die Compilerparameter verwendet. Der Compiler definiert intern eine dem mmcu-Parameter zugeordnete "Variable" (genauer: ein Makro) mit dem Namen des Controllers, vorangestelltem ''__AVR_'' und angehängten Unterstrichen (z. B. wird bei ''-mmcu=atmega16'' das Makro ''__AVR_ATmega16__'' definiert). Beim Einbinden der Header-Datei ''avr/io.h'' wird geprüft, ob das jeweilige Makro definiert ist und die zum Controller passende Definitionsdatei eingelesen. Zur Veranschaulichung einige Ausschnitte aus einem Makefile:

<pre>
[...]
# MCU Type ("name") setzen:
MCU = atmega16
[...]

[...]
## Verwendung des Inhalts von MCU (hier atmega16) fuer die
## Compiler- und Assembler-Parameter
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
[...]

[...]
## Aufruf des Compilers:
## mit den Parametern ($(ALL_CFLAGS) ist -mmcu=$(MCU)[...] = -mmcu=atmega16[...]
$(OBJDIR)/%.o : %.c
@echo
@echo $(MSG_COMPILING) $<
$(CC) -c $(ALL_CFLAGS) $< -o $@
[...]
</pre>

Da --mmcu=atmega16 übergeben wurde, wird __AVR_ATmega16__ definiert und kann in avr/io.h zur Fallunterscheidung genutzt werden:

<c>
// avr/io.h
// (bei WinAVR-Standardinstallation in C:\WinAVR\avr\include\avr)
[...]
#if defined (__AVR_AT94K__)
# include <avr/ioat94k.h>
// [...]
#elif defined (__AVR_ATmega16__)
// da __AVR_ATmega16__ definiert ist, wird avr/iom16.h eingebunden:
# include <avr/iom16.h>
// [...]
#else
# if !defined(__COMPILING_AVR_LIBC__)
# warning "device type not defined"
# endif
#endif
</c>

Die Beispiele in den folgenden Abschnitten demonstrieren den Zugriff auf Register anhand der Register für I/O-Ports (PORTx, DDRx, PINx), die Vorgehensweise ist jedoch für alle Register (z. B. die des UART, ADC, SPI) analog.

== Schreiben in Register ==

Zum Schreiben kann man Register einfach wie eine Variable setzen.<ref>In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Schreibzugriff über die Funktion outp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt, outp() ist nicht mehr erforderlich.</ref>

Beispiel:

<c>
#include <avr/io.h>

int main()
{
/* Setzt das Richtungsregister des Ports A auf 0xff
(alle Pins als Ausgang, vgl. Abschnitt Zugriff auf Ports): */
DDRA = 0xff;

/* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low": */
PORTA = 0x03;

// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
DDRB = 0x1F; /* direkte Zuweisung - unübersichtlich */

/* Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
aber übersichtlicher und selbsterklärend: */
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);

while (1);
}
</c>

Die ausführliche Schreibweise sollte bevorzugt verwendet werden, da dadurch die Zuweisungen selbsterklärend sind und somit der Code leichter nachvollzogen werden kann. Atmel verwendet sie auch bei Beispielen in Datenblätten und in den allermeisten Quellcodes zu Application-Notes. Mehr zu der Schreibweise mit "|" und "<<" findet man unter [[Bitmanipulation]].

Der gcc C-Compiler unterstützt ab Version 4.3.0 Konstanten im Binärformat, z. B. DDRB = 0b00011111. Diese Schreibweise ist jedoch nur in GNU-C verfügbar und nicht in ISO-C definiert. Man sollte sie daher nicht verwenden, wenn Code mit anderen ausgetauscht oder mit anderen Compilern bzw. älteren Versionen des gcc genutzt werden soll.

== Verändern von Registerinhalten ==

Einzelne Bits setzt und löscht man "Standard-C-konform" mittels logischer (Bit-) Operationen.

<c>
x |= (1 << Bitnummer); // Hiermit wird ein Bit in x gesetzt
x &= ~(1 << Bitnummer); // Hiermit wird ein Bit in x geloescht
</c>

Es wird jeweils nur der Zustand des angegebenen Bits geändert, der vorherige Zustand der anderen Bits bleibt erhalten.

Beispiel:
<c>
#include <avr/io.h>
...
#define MEINBIT 2
...
PORTA |= (1 << MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1 << MEINBIT); /* loescht Bit 2 an PortA */
</c>

Mit dieser Methode lassen sich auch mehrere Bits eines Registers gleichzeitig setzen und löschen.

Beispiel:
<c>
#include <avr/io.h>
...
DDRA &= ~( (1<<PA0) | (1<<PA3) ); /* PA0 und PA3 als Eingaenge */
PORTA |= (1<<PA0) | (1<<PA3); /* Interne Pull-Up fuer beide einschalten */
</c>

Bei bestimmten AVR Registern mit Bits, die durch Beschreiben mit einer logischen 1 gelöscht werden, muss eine absolute Zuweisung benutzt werden. Ein ODER löscht in diesen Registern ALLE gesetzten Bits!

Beispiel:
<c>
#include <avr/io.h>
...
TIFR2 = (1<<OCF2A); // Nur Bit OCF2A löschen
</c>

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind nicht mehr erforderlich.

Siehe auch:
* [[Bitmanipulation]]
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

== Lesen aus Registern ==

Zum Lesen kann man auf Register einfach wie auf eine Variable zugreifen. In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Lesezugriff über die Funktion inp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt und inp() ist nicht mehr erforderlich.

Beispiel:

<c>
#include <avr/io.h>
#include <stdint.h>

uint8_t foo;

//...

int main(void)
{
/* kopiert den Status der Eingabepins an PortB
in die Variable foo: */
foo = PINB;
//...
}
</c>

Die Abfrage der Zustände von Bits erfolgt durch Einlesen des gesamten Registerinhalts und ausblenden der Bits deren Zustand nicht von Interesse ist. Einige Beispiele zum Prüfen ob Bits gesetzt oder gelöscht sind:

<c>
#define MEINBIT0 0
#define MEINBIT2 2

uint8_t i;

extern test1();

// Funkion test1 aufrufen, wenn Bit 0 in Register PINA gesetzt (1) ist
i = PINA; // Inhalt in Arbeitsvariable
i = i & 0x01; // alle Bits bis auf Bit 0 ausblenden (bitweise und)
// falls das Bit gesetzt war, hat i den Inhalt 1
if ( i != 0 ) { // Ergebnis ungleich 0 (wahr)?
test1(); // dann muss Bit 0 in i gesetzt sein -> Funktion aufrufen
}
// verkürzt:
if ( ( PINA & 0x01 ) != 0 ) {
test1();
}
// nochmals verkürzt:
if ( PINA & 0x01 ) {
test1();
}
// mit definierter Bitnummer:
if ( PINA & ( 1 << MEINBIT0 ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 und/oder Bit 2 gesetzt ist. (Bit 0 und 2 also Wert 5)
// (Bedenke: Bit 0 hat Wert 1, Bit 1 hat Wert 2 und Bit 2 hat Wert 4)
if ( PINA & 0x05 ) {
test1(); // Vergleich <> 0 (wahr), also mindestens eines der Bits gesetzt
}
// mit definierten Bitnummern:
if ( PINA & ( ( 1 << MEINBIT0 ) | ( 1 << MEINBIT2 ) ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 und Bit 2 gesetzt sind
if ( ( PINA & 0x05 ) == 0x05 ) { // nur wahr, wenn beide Bits gesetzt
test1();
}

// Funktion test2() aufrufen, wenn Bit 0 gelöscht (0) ist
i = PINA; // einlesen in temporäre Variable
i = i & 0x01; // maskieren von Bit 0
if ( i == 0 ) { // Vergleich ist wahr, wenn Bit 0 nicht gesetzt ist
test2();
}
// analog mit not-Operator
if ( !i ) {
test2();
}
// nochmals verkürzt:
if ( !( PINA & 0x01 ) ) {
test2();
}
</c>

== Warten auf einen bestimmten Zustand ==

Es gibt in der Bibliothek avr-libc Funktionen, die warten, bis ein bestimmter Zustand eines Bits erreicht ist. Es ist allerdings normalerweise eine eher unschöne Programmiertechnik, da in diesen Funktionen "blockierend" gewartet wird. Der Programmablauf bleibt also an dieser Stelle stehen, bis das maskierte Ereignis erfolgt ist. Setzt man den [[Watchdog]] ein, muss man darauf achten, dass dieser auch noch getriggert wird (Zurücksetzen des Watchdogtimers).

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits gesetzt ist, wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT PA2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1 << WARTEBIT)) ) {}
...
</c>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits gelöscht ist, wird die Funktion sofort wieder verlassen.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT PB4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// gesetzt (1) ist
while ( WARTEPIN & (1<<WARTEBIT) ) {}
...
</c>

Universeller und auch auf andere Plattformen besser übertragbar ist die Verwendung von C-Standardoperationen.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]

== 16-Bit Register (ADC, ICR1, OCR1x, TCNT1, UBRR) ==

Einige der Portregister in den AVR-Controllern sind 16 Bit breit. Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (Low-Byte) und "H" (High-Byte) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese Register kann dann direkt zugegriffen werden. Dies ist zum Beispiel der Fall für Register wie ADC oder TCNT1.
<c>
#include <avr/io.h>
...
uint16_t foo;

/* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
foo = ADC;
</c>

Bei anderen Registern, wie zum Beispiel Baudraten-Register, liegen High- und Low-Teil nicht direkt nebeneinander im SFR-Bereich, so dass ein 16-Bit Zugriff nicht möglich ist und der Zugriff zusammengebastelt werden muss:

<c>
#include <avr/io.h>

#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

...
uint16_t baud = F_CPU / (UART_BAUD_RATE * 16L) -1;

UBRRH = (uint8_t) (baud >> 8);
UBRRL = (uint8_t) baud;
...
</c>

Bei einigen AVR-Typen wie ATmega8 oder ATmega16 teilen sich UBRRH und UCSRC die gleiche Speicher-Adresse. Damit der AVR trotzdem zwischen den beiden Registern unterscheiden kann, bestimmt das Bit7 (URSEL), welches Register tatsächlich beschrieben werden soll. ''1000 0011'' (0x83) adressiert demnach UCSRC und übergibt den Wert ''3'' und ''0000 0011'' (0x3) adressiert UBRRH und übergibt ebenfalls den Wert ''3''.

Speziell bei den 16-Bit-Timern und auch beim ADC ist es bei allen Zugriffen auf Datenregister erforderlich, dass diese Daten synchronisiert sind. Wenn z. B. bei einem 16-Bit-Timer das High-Byte des Zählregisters gelesen wurde und vor dem Lesezugriff auf das Low-Byte ein Überlauf des Low-Bytes stattfindet, erhält man einen völlig unsinnigen Wert. Auch die Compare-Register müssen synchron geschrieben werden, da es ansonsten zu unerwünschten Compare-Ereignissen kommen kann.

Beim ADC besteht das Problem darin, dass zwischen den Zugriffen auf die beiden Teilregister eine Wandlung beendet werden kann und der ADC ein neues Ergebnis in ADCL und ADCH schreiben will, wodurch High- und Low-Byte nicht zusammenpassen.

Um diese Datenmüllproduktion zu verhindern, gibt es in beiden Fällen eine Synchronisation, die jeweils durch den Zugriff auf das Low-Byte ausgelöst wird:
* Bei den Timer-Registern (das gilt für alle TCNT-, OCR- und ICR-Register bei den 16-Bit-Timern) wird bei einem ''Lesezugriff'' auf das Low-Byte automatisch das High-Byte in ein temporäres Register, das ansonsten nach außen nicht sichtbar ist, geschoben. Greift man nun ''anschließend'' auf das High-Byte zu, dann wird eben dieses temporäre Register gelesen.
* Bei einem ''Schreibzugriff'' auf eines der genannten Register wird das High-Byte in besagtem temporären Register zwischengespeichert und erst beim Schreiben des Low-Bytes werden ''beide'' gleichzeitig in das eigentliche Register übernommen.

Das bedeutet für die Reihenfolge:
* Lesezugriff: Erst Low-Byte, dann High-Byte
* Schreibzugriff: Erst High-Byte, dann Low-Byte

Des weiteren ist zu beachten, dass es für all diese 16-Bit-Register nur ein einziges temporäres Register gibt, so dass das Auftreten eines Interrupts, in dessen Handler ein solches Register manipuliert wird, bei einem durch ihn unterbrochenen Zugriff i.d.R. zu Datenmüll führt. 16-Bit-Zugriffe sind generell nicht atomar! Wenn mit Interrupts gearbeitet wird, kann es erforderlich sein, vor einem solchen Zugriff auf ein 16-Bit-Register die Interrupt-Bearbeitung zu deaktivieren.

Beim ADC-Datenregister ADCH/ADCL ist die Synchronisierung anders gelöst. Hier wird beim Lesezugriff (ADCH/ADCL sind logischerweise read-only) auf das Low-Byte ADCL beide Teilregister für Zugriffe seitens des ADC so lange gesperrt, bis das High-Byte ADCH ausgelesen wurde. Dadurch kann der ADC nach einem Zugriff auf ADCL keinen neuen Wert in ADCH/ADCL ablegen, bis ADCH gelesen wurde. Ergebnisse von Wandlungen, die zwischen einem Zugriff auf ADCL und ADCH beendet werden, gehen verloren!

Nach einem Zugriff auf ADCL muss grundsätzlich ADCH gelesen werden!

In beiden Fällen – also sowohl bei den Timern als auch beim ADC – werden vom C-Compiler 16-Bit Pseudo-Register zur Verfügung gestellt (z. B. TCNT1H/TCNT1L → TCNT1, ADCH/ADCL → ADC bzw. ADCW), bei deren Verwendung der Compiler automatisch die richtige Zugriffsreihenfolge regelt. In C-Programmen sollten grundsätzlich diese 16-Bit-Register verwendet werden! Sollte trotzdem ein Zugriff auf ein Teilregister erforderlich sein, sind obige Angaben zu berücksichtigen.

Es ist darauf zu achten, dass auch ein Zugriff auf die 16-Bit-Register vom Compiler in zwei 8-Bit-Zugriffe aufgeteilt wird und dementsprechend genauso nicht-atomar ist wie die Einzelzugriffe. Auch hier gilt, dass u.U. die Interrupt-Bearbeitung gesperrt werden muss, um Datenmüll zu vermeiden.

Beim ADC gibt es für den Fall, dass eine Auflösung von 8 Bit ausreicht, die Möglichkeit, das Ergebnis "linksbündig" in ADCH/ADCL auszurichten, so dass die relevanten 8 MSB in ADCH stehen. In diesem Fall muss bzw. sollte nur ADCH ausgelesen werden.

ADC und ADCW sind unterschiedliche Bezeichner für das selbe Registerpaar. Üblicherweise kann man in C-Programmen ADC verwenden, was analog zu den anderen 16-Bit-Registern benannt ist. ADCW (ADC Word) existiert nur deshalb, weil die Headerdateien auch für Assembler vorgesehen sind und es bereits einen Assembler-Befehl namens ''adc'' gibt.

Im Umgang mit 16-Bit Registern siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8
* Datenblatt Abschnitt ''Accessing 16-bit Registers''

== IO-Register als Parameter und Variablen ==

Um Register als Parameter für eigene Funktionen übergeben zu können, muss man sie als einen volatile uint8_t Pointer übergeben. Zum Beispiel:

<c>
#include <avr/io.h>
#include <util/delay.h>

uint8_t key_pressed (volatile uint8_t *inputreg, uint8_t inputbit)
{
static uint8_t last_state = 0;

if (last_state == (*inputreg & (1<<inputbit)))
return 0; /* keine Änderung */

/* Wenn doch, warten bis etwaiges Prellen vorbei ist: */
_delay_ms(20);

/* Zustand für nächsten Aufruf merken: */
last_state = *inputreg & (1<<inputbit);

/* und den entprellten Tastendruck zurückgeben: */
return *inputreg & (1<<inputbit);
}

/* Beispiel für einen Funktionsaufruf: */

void foo (void)
{
uint8_t i = key_pressed (&PINB, PB1);
}
</c>

Ein Aufruf der Funktion mit call by value würde Folgendes bewirken: Beim Funktionseintritt wird nur eine Kopie des momentanen Portzustandes angefertigt, die sich unabhängig vom tatsächlichen Zustand das Ports nicht mehr ändert, womit die Funktion wirkungslos wäre. Die Übergabe eines Zeigers wäre die Lösung, wenn der Compiler nicht optimieren würde. Denn dadurch wird im Programm nicht von der Hardware gelesen, sondern wieder nur von einem Abbild im Speicher. Das Ergebnis wäre das gleiche wie oben. Mit dem Schlüsselwort volatile sagt man nun dem Compiler, dass die entsprechende Variable entweder durch andere Softwareroutinen (Interrupts) oder durch die Hardware verändert werden kann.

Siehe auch: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass avr-libc FAQ: "How do I pass an IO port as a parameter to a function?"]

= Zugriff auf IO-Ports =

Jeder AVR implementiert eine unterschiedliche Menge an GPIO-Registern
(GPIO - General Purpose Input/Output). Diese Register dienen dazu:
* einzustellen welche der Anschlüsse ("Beinchen") des Controllers als Ein- oder Ausgänge dienen
* bei Ausgängen deren Zustand festzulegen
* bei Eingängen deren Zustand zu erfassen

Mittels GPIO werden digitale Zustände gesetzt und erfasst, d.h. die Spannung an einem Ausgang wird ein- oder ausgeschaltet und an einem Eingang wird erfasst, ob die anliegende Spannung über oder unter einem bestimmten Schwellwert liegt. Im Datenblatt Abschnitt Electrical Characteristics/DC Characteristics finden sich die Spannungswerte (V_OL, V_OH für Ausgänge, V_IL, V_IH für Eingänge).

Die Verarbeitung von analogen Eingangswerten und die Ausgabe von Analogwerten wird in Kapitel [[AVR-GCC-Tutorial#Analoge_Ein-_und_Ausgabe|Analoge Ein- und Ausgabe]] behandelt.

Die physischen Ein- und Ausgänge werden bei AVR-Controllern zu logischen Ports gruppiert.

Alle Ports werden über Register gesteuert. Dazu sind jedem Port 3 Register zugeordnet:

{| class="wikitable"
|-
! DDRx
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (abhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
! PINx
| Eingangsadresse für Port'''x'''.
Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der als Eingang definierten Portpins. Bit 1 wenn Pin "high", Bit 0 wenn Portpin low.
|-
! PORTx
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Bei Pins, die mittels DDRx auf Eingang geschaltet wurden, können über PORTx
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|}

Die folgenden Beispiele gehen von einem AVR aus, der sowohl Port A als auch Port B besitzt. Sie müssen für andere AVRs (zum Beispiel ATmega8/48/88/168) entsprechend angepasst werden.

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.

Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Beispiel:
Angenommen am Port B sollen die Pins 0 bis 4 als Ausgänge definiert werden, die noch verbleibenden Pins 5 bis 7 sollen als Eingänge fungieren. Dazu ist es daher notwendig, im für das Port B zuständigen Datenrichtungsregister DDRB folgende Bitkonfiguration einzutragen

+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |

In C liest sich das dann so:

<c>
// in io.h wird u.a. DDRB definiert:
#include <avr/io.h>

int main()
{
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
// direkte Zuweisung - standardkonform */
DDRB = 0x1F; /*

// übersichtliche Alternative - Binärschreibweise, aber kein ISO-C
DDRB = 0b00011111;

// Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
// aber übersichtlicher und selbsterklärend:
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);
</c>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet. Weitere Beispiele:

<c>
// Alle Pins des Ports B als Ausgang definieren:
DDRB = 0xff;
// Pin0 wieder auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~(1 << DDB0);
// Pin 3 und 4 auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~((1 << DDB3) | (1 << DDB4));
// Pin 0 und 3 wieder auf Ausgang und andere im ursprünglichen Zustand belassen:
DDRB |= (1 << DDB0) | (1 << DDB3);
// Alle Pins auf Eingang:
DDRB = 0x00;
</c>

== Vordefinierte Bitnummern für I/O-Register ==

Die Bitnummern (z. B. PCx, PINCx und DDCx für den Port C) sind in den io*.h-Dateien der avr-libc definiert und dienen lediglich der besseren Lesbarkeit. Man muss diese Definitionen nicht verwenden oder kann auch einfach "immer" PAx, PBx, PCx usw. nutzen, auch wenn der Zugriff auf Bits in DDRx- oder PINx-Registern erfolgt. Für den Compiler sind die Ausdrücke (1<<PC7), (1<<DDC7) und (1<<PINC7) identisch zu (1<<7) (genauer: der Präprozessor ersetzt die Ausdrücke (1<<PC7),... zu (1<<7)). Ein Ausschnitt der Definitionen für Port C eines ATmega32 aus der iom32.h-Datei zur Verdeutlichung (analog für die weiteren Ports):

<c>
...
/* PORTC */
#define PC7 7
#define PC6 6
#define PC5 5
#define PC4 4
#define PC3 3
#define PC2 2
#define PC1 1
#define PC0 0

/* DDRC */
#define DDC7 7
#define DDC6 6
#define DDC5 5
#define DDC4 4
#define DDC3 3
#define DDC2 2
#define DDC1 1
#define DDC0 0

/* PINC */
#define PINC7 7
#define PINC6 6
#define PINC5 5
#define PINC4 4
#define PINC3 3
#define PINC2 2
#define PINC1 1
#define PINC0 0
</c>

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen bzw. auszugeben.

== Ausgänge ==
Will man als Ausgang definierte Pins (entsprechende DDRx-Bits = 1) auf Logisch 1 setzen, setzt man die entsprechenden Bits im Portregister.

Mit dem Befehl
<c>
#include <avr/io.h>
...
PORTB = 0x04; /* besser PORTB=(1<<PB2) */

// übersichtliche Alternative - Binärschreibweise
PORTB = 0b00000100; /* direkte Zuweisung - übersichtlich */

</c>
wird also der Ausgang an Pin PB2 gesetzt (Beachte, dass die Bits immer ''von 0 an'' gezählt werden, das niederwertigste Bit ist also Bitnummer 0 und nicht etwa Bitnummer 1).

Man beachte, dass bei der Zuweisung mittels '''=''' immer alle Pins gleichzeitig angegeben werden. Man sollte also, wenn nur bestimmte Ausgänge geschaltet werden sollen, zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfließen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an Port B auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<c>
#include <avr/io.h>
...
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<PB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<PB2);

/* auch mehrere "gleichzeitig": */
PORTB |= (1<<PB4) | (1<<PB5); /* Pins PB4 und PB5 "high" */
</c>

"Ausschalten", also Ausgänge auf "low" setzen, erfolgt analog:

<c>
#include <avr/io.h>
...
PORTB &= ~(1<<PB2); /* löscht Bit 2 in PORTB und setzt damit Pin PB2 auf low */
PORTB &= ~( (1<<PB4) | (1<<PB5) ); /* Pin PB4 und Pin PB5 "low" */
</c>
Siehe auch [[Bitmanipulation]]

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind in aktuellen Versionen der avr-libc nicht mehr enthalten und auch nicht mehr erforderlich.

''Falls der Anfangszustand von Ausgängen kritisch ist, muss die Reihenfolge beachtet werden, mit der die Datenrichtung (DDRx) eingestellt und der Ausgabewert (PORTx) gesetzt wird:''

Für Ausgangspins, die mit Anfangswert "high" initialisiert werden sollen:
* zuerst die Bits im PORTx-Register setzen
* anschließend die Datenrichtung auf Ausgang stellen

Daraus ergibt sich die Abfolge für einen Pin, der bisher als Eingang mit abgeschaltetem Pull-Up konfiguriert war:
* setze PORTx: interner Pull-Up aktiv
* setze DDRx: Ausgang ("high")

Bei der Reihenfolge erst DDRx und dann PORTx kann es zu einem kurzen "low-Puls" kommen, der auch externe Pull-Up-Widerstände "überstimmt". Die (ungünstige) Abfolge: Eingang -> setze DDRx: Ausgang (auf "low", da PORTx nach Reset 0) -> setze PORTx: Ausgang auf high. Vergleiche dazu auch das Datenblatt Abschnitt ''Configuring the Pin''.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wir den Pegel über entsprechende Hardware (z. B. Optokoppler, [[Widerstand#Spannungsteiler|Spannungsteiler]], "Levelshifter" aka [[Pegelwandler]]) anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unseres Controllers eine logische 1 (Spannung größer ca. 0,7*Vcc) oder eine logische 0 (Spannung kleiner ca. 0,2*Vcc) anliegt. Detaillierte Informationen darüber, ab welcher Spannung ein Eingang als 0 ("low") bzw. 1 ("high") erkannt wird, liefert die Tabelle DC Characteristics im Datenblatt des genutzten Controllers.

{| class="wikitable" style="text-align:center"
|+ '''Spannungstabelle''' (ca. Grenzwerte)
|
! Low || High
|-
! bei 5 V
| 1 V || 3,5 V
|-
! bei 3,3 V
| 0,66 V || 2,31 V
|-
! bei 1,8 V
| 0,36 V || 1,26 V
|}

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.

{{Warnung|Dabei ist wichtig, zur Abfrage der Eingänge ''nicht'' etwa Portregister '''PORTx''' zu verwenden, sondern Eingangsregister '''PINx'''. Ansonsten liest man nicht den Zustand der Eingänge, sondern den Status der internen Pull-Up-Widerstände. Die Abfrage der Pinzustände über PORTx statt PINx ist ein häufiger Fehler beim AVR-"Erstkontakt".}}

Will man also die aktuellen Signalzustände von Port D abfragen und in eine Variable namens bPortD abspeichern, schreibt man folgende Befehlszeilen:

<c>
#include <avr/io.h>
#include <stdint.h>
...
uint8_t bPortD;
...
bPortD = PIND;
...
</c>

Mit den C-Bitoperationen kann man den Status der Bits abfragen.

<c>
#include <avr/io.h>
...
/* Fuehre Aktion aus, wenn Bit Nr. 1 (das "zweite" Bit) in PINC gesetzt (1) ist */
if ( PINC & (1<<PINC1) ) {
/* Aktion */
}

/* Fuehre Aktion aus, wenn Bit Nr. 2 (das "dritte" Bit) in PINB geloescht (0) ist */
if ( !(PINB & (1<<PINB2)) ) {
/* Aktion */
}
...
</c>
Siehe auch [[Bitmanipulation#Bits_prüfen]]

=== Interne Pull-Up Widerstände ===

Portpins für Ein- und Ausgänge (GPIO) eines AVR verfügen über zuschaltbare interne Pull-Up Widerstände (nominal mehrere 10kOhm, z. B. ATmega16 20-50kOhm). Diese können in vielen Fällen statt externer Widerstände genutzt werden.

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang''' geschaltet ist.

Wird der Wert des entsprechenden Portpins auf 1 gesetzt, so ist der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up Widerstand nicht aktiv. Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand verwenden, aber nicht beide zusammen.

Im Beispiel werden alle Pins des Ports D als Eingänge geschaltet und alle Pull-Up Widerstände aktiviert. Weiterhin wird Pin PC7 als Eingang geschaltet und dessen interner Pull-Up Widerstand aktiviert, ohne die Einstellungen für die anderen Portpins (PC0-PC6) zu verändern.

<c>
#include <avr/io.h>
...
DDRD = 0x00; /* alle Pins von Port D als Eingang */
PORTD = 0xff; /* interne Pull-Ups an allen Port-Pins aktivieren */
...
DDRC &= ~(1<<PC7); /* Pin PC7 als Eingang */
PORTC |= (1<<PC7); /* internen Pull-Up an PC7 aktivieren */
</c>

=== Taster und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller, ist zwischen zwei unterschiedliche Methoden zu unterscheiden: ''Active Low'' und ''Active High''.

<gallery widths="300" heights="300" caption="Anschluss mechanischer Kontakte an einen µC">
Image:Active Low.gif|'''Active Low:''' Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet. Damit bei offenem Schalter der Controller kein undefiniertes Signal bekommt, wird zwischen die Versorgungsspannung und den Eingangspin ein sogenannter '''Pull-Up''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffnetem Schalter auf logisch 1 zu ziehen.
Image:Active High.gif|'''Active High:''' Hier wird der Kontakt zwischen die Versorgungsspannung und den Eingangspin geschaltet. Damit bei offener Schalterstellung kein undefiniertes Signal am Controller ansteht, wird zwischen den Eingangspin und die Masse ein '''Pull-Down''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter Schalterstellung auf logisch 0 zu halten.
</gallery>

Der Widerstandswert von Pull-Up- und Pull-Down-Widerständen ist an sich nicht kritisch. Wird er allerdings zu hoch gewählt, ist die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10 kOhm eingebürgert. Die AVRs verfügen an den meisten Pins über zuschaltbare interne Pull-Up Widerstände (vgl. Abschnitt [[AVR-GCC-Tutorial#Interne Pull-Up Widerstände|Interne Pull-Up Widerstände]]), welche insbesondere wie hier bei Tastern und ähnlichen Bauteilen (z. B. Drehgebern) statt externer Bauteile verwendet werden können. Interne Pull-Down-Widerstand sind nicht verfügbar und müssen daher in Form zusätzlicher Bauteile in die Schaltung eingefügt werden.

==== Taster entprellen ====

Siehe: ''[[Entprellung#Warteschleifen-Verfahren|Entprellung: Warteschleifen-Verfahren]]

= Warteschleifen (delay.h) =

Der Programmablauf kann verschiedene Arten von Wartefunktionen erfordern:

* Warten im Sinn von Zeitvertrödeln
* Warten auf einen bestimmten Zustand an den I/O-Pins
* Warten auf einen bestimmten Zeitpunkt (siehe Timer)
* Warten auf einen bestimmten Zählerstand (siehe Counter)

Der einfachste Fall, das Zeitvertrödeln, kann in vielen Fällen und mit großer Genauigkeit anhand der avr-libc Bibliotheksfunktionen _delay_ms() und _delay_us() erledigt werden. Die Bibliotheksfunktionen sind einfachen Zählschleifen (Warteschleifen) vorzuziehen, da leere Zählschleifen ohne besondere Vorkehrungen sonst bei eingeschalteter Optimierung vom avr-gcc-Compiler wegoptimiert werden. Weiterhin sind die Bibliotheksfunktionen bereits darauf vorbereitet, die in F_CPU definierte Taktfrequenz zu verwenden. Außerdem sind die Funktionen der Bibliothek wirklich getestet.

Einfach!? Schon, aber während gewartet wird, macht der µC nichts anderes mehr (abgesehen von möglicherweise auftretenden Interrupts, falls welche aktiviert sind). Die Wartefunktion blockiert den Programmablauf. Möchte man einerseits warten, um z. B. eine LED blinken zu lassen und gleichzeitig andere Aktionen ausführen z. B. weitere LED bedienen, sollten die Timer/Counter des AVR verwendet werden.

Die Bibliotheksfunktionen funktionieren allerdings nur dann korrekt, wenn sie mit zur Übersetzungszeit (beim Compilieren) bekannten konstanten Werten aufgerufen werden. Der Quellcode muss mit eingeschalteter Optimierung übersetzt werden, sonst wird sehr viel Maschinencode erzeugt, und die Wartezeiten stimmen nicht mehr mit dem Parameter überein.

Eine weitere Einschränkung liegt darin, daß sie möglicherweise länger warten, als erwartet, nämlich in dem Fall, daß Interrupts auftreten und die _delay...()-Funktion unterbrechen. Genau genommen warten diese nämlich nicht eine bestimmte Zeit, sondern verbrauchen eine bestimmte Anzahl von Prozessortakten. Die wiederum ist so bemessen, daß ohne Unterbrechung durch Interrupts die gewünschte Wartezeit erreicht wird.
Wird das Warten aber durch eine oder mehrere ISR unterbrochen, die zusammen 1% Prozessorzeit verbrauchen, dann dauert das Warten etwa 1% länger. Bei 50% Last durch die ISR dauert das Warten doppelt solange wie gewünscht, bei 90% zehnmal solange...

Abhängig von der Version der Bibliothek verhalten sich die Bibliotheksfunktionen etwas unterschiedlich.

== avr-libc Versionen kleiner 1.6 ==

Die Wartezeit der Funktion _delay_ms() ist auf 262,14ms/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 13,1ms warten. Die Wartezeit der Funktion _delay_us() ist auf 768us/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 38,4µs warten. Längere Wartezeiten müssen dann über einen mehrfachen Aufruf in einer Schleife gelöst werden.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z. B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h> /* in älteren avr-libc Versionen <avr/delay.h> */

/*
lange, variable Verzögerungszeit, Einheit in Millisekunden

Die maximale Zeit pro Funktionsaufruf ist begrenzt auf
262.14 ms / F_CPU in MHz (im Beispiel:
262.1 / 3.6864 = max. 71 ms)

Daher wird die kleine Warteschleife mehrfach aufgerufen,
um auf eine längere Wartezeit zu kommen. Die zusätzliche
Prüfung der Schleifenbedingung lässt die Wartezeit geringfügig
ungenau werden (macht hier vielleicht 2-3ms aus).
*/

void long_delay(uint16_t ms)
{
for(; ms>0; ms--) _delay_ms(1);
}

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) // Endlosschleife
{
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z. B. angeschlossene LED
long_delay(1000); // Eine Sekunde warten...
}

return 0;
}
</c>

== avr-libc Versionen ab 1.6 ==

_delay_ms() kann mit einem Argument bis 6553,5 ms (= 6,5535 Sekunden) benutzt werden. Es ist nicht möglich, eine Variable als Argument zu übergeben. Wird die früher gültige Grenze von 262,14 ms/F_CPU (in MHz) überschritten, so arbeitet _delay_ms() einfach etwas ungenauer und zählt nur noch mit einer Auflösung von 1/10 ms. Eine Verzögerung von 1000,10 ms ließe sich nicht mehr von einer von 1000,19 ms unterscheiden. Ein Verlust, der sich im Allgemeinen verschmerzen lässt. Dem Programmierer wird keine Rückmeldung gegeben, dass die Funktion ggf. gröber arbeitet, d.h. wenn es darauf ankommt, bitte den Parameter wie bisher geschickt wählen.

Die Funktion _delay_us() wurde ebenfalls erweitert. Wenn deren maximal als genau behandelbares Argument überschritten wird, benutzt diese intern _delay_ms(). Damit gelten in diesem Fall die _delay_ms() Einschränkungen.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus, avr-libc ab Version 1.6
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z.B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h>

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z.B. angeschlossene LED
_delay_ms(1000); // Eine Sekunde +/-1/10000 Sekunde warten...
// funktioniert nicht mit Bibliotheken vor 1.6

}
return 0;
}
</c>

Trick zur Übergabe einer Variablen an _delay_ms():
<c>
#include <avr/io.h>
#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h>

void sleep ( uint8_t ms )
{
for(; ms > 0; ms--) _delay_ms(1);
}

int main( void )
{
int x = 0; // Variable als Wartezeit erstellen
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z.B. angeschlossene LED
sleep(x);
x++;
}
return 0;
}
</c>

Die _delay_ms() und die _delay_us aus '''avr-libc 1.7.0''' sind fehlerhaft. _delay_ms () läuft 4x schneller als erwartet. Abhilfe ist eine korrigierte Includedatei: [http://www.mikrocontroller.net/topic/196738#1943039]

= Programmieren mit Interrupts =

<div style="float:right; margin:2em;">
[[Image:Interrupt Programme.gif]]
</div>
Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Tritt ein Interrupt auf, unterbricht (engl. interrupts) der Controller die Verarbeitung des Hauptprogramms und verzweigt zu einer Interruptroutine. Das Hauptprogramm wird also beim Eintreffen eines Interrupts unterbrochen, die Interruptroutine ausgeführt und danach erst wieder das Hauptprogramm an der Unterbrechungsstelle fortgesetzt (vgl. die Abbildung).

Um Interrupts verarbeiten zu können, ist folgendes zu beachten:

* Für jede aktivierte Interruptquelle ist eine Funktion zu programmieren, in der die beim Auftreten des jeweiligen Interrupts erforderlichen Verarbeitungsschritte enthalten sind. Für diese Funktion exisiteren verschiede Bezeichnungen. Üblich sind die englischen Begriffe Interrupt-Handler oder Interrupt-Service-Routinen (ISR), man findet aber auch die Bezeichnungen Interruptverarbeitungs- oder -behandlungsroutine oder auch kurz Interuptroutine. Zum Beispiel wird üblicherweise in der ISR zur Verarbeitung des Empfangsinterrupts eines UARTs (UART-RX Interrupt) das empfangene Zeichen in einen Zwischenspeicher (FIFO-Buffer) kopiert, dessen Inhalt später von anderen Programmteilen geleert wird. Sofern der Zwischenspeicher ausreichend groß ist, geht also kein Zeichen verloren, auch wenn im Hauptprogramm zeitintensive Operationen durchgeführt werden.
* Die benötigten Interrupts sind in den jeweiligen Funktionsbausteinen einzuschalten. Dies erfolgt über das jeweilige Aktivierungsbit (Interrupt Enable) in einem der Hardwareregister (z.B. RX(Complete)Interrupt Enable eines UARTs)
* Sämtliche Interrupts werden über einen weiteren globalen Schalter aktiviert und deaktiviert. Zur Verarbeitung der Interrupts ist dieser Schalter zu aktivieren (sei(), siehe untern).

Alle Punkte sind zu beachten. Fehlt z.B. die globale Aktivierung, werden Interruptroutinen auch dann nicht aufgerufen, wenn sie im Funktionsbaustein eingeschaltet sind und eine Behandlungsroutine verhanden ist.

Siehe auch

* [http://www.mikrocontroller.net/forum/read-1-235092.html#new Ausführlicher Thread im Forum]
* Artikel [[Interrupt]]
* Artikel [[Multitasking]]
{{Clear}}

== Anforderungen an Interrupt-Routinen ==

Um unliebsamen Überraschungen vorzubeugen, sollten einige Grundregeln bei der Implementierung der Interruptroutinen beachtet werden. Interruptroutinen sollten möglichst kurz und schnell abarbeitbar sein, daraus folgt:

* Keine umfangreichen Berechnungen innerhalb der Interruptroutine. (*)
* Keine langen Programmschleifen.
* Obwohl es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen, wird davon ohne genaue Kenntnis der internen Abläufe dringend abgeraten.

Interruptroutinen (ISRs) sollten also möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

(*)
Hinweis:
Es gibt allerdings die seltene Situation, dass man gerade eingelesene
ADC-Werte sofort verarbeiten muss. Besonders dann, wenn man mehrere Werte sehr
schnell hintereinander bekommt. Dann bleibt einem nichts anderes übrig, als die
Werte noch in der ISR zu verarbeiten. Kommt aber sehr selten vor und sollte
durch geeignete Wahl des Systemtaktes bzw. Auswahl des Controllers vermieden werden!

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf einem AVR AT90S2313 auslösen, wobei die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

Die Anzahl der möglichen Interruptquellen variiert zwischen den verschiedenen Microcontroller-Typen. Im Zweifel hilft ein Blick ins Datenblatt ("Interrupt Vectors").

== Register ==

Der AT90S2313 verfügt über 2 Register die mit den
Interrupts zusammen hängen.

{| class="wikitable"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''a'''sk''' Register. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6|| 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INT1''' || '''INT0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INTF1''' || '''INTF0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Bedingung, entsprechend der Konfiguration, als eingetreten erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Bedingung, entsprechend der Konfiguration, als eingetreten erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine MCU-Funktionen.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''-'''|| '''-'''|| '''SE'''|| '''SM'''|| '''ISC11'''|| '''ISC10'''|| '''ISC01'''|| '''ISC00'''
|-
! R/W
| R || R || R/W || R/W || R/W || R/W || R/W || R/W
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0

|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt über den Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC11 || ISC10 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}

'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC01 || ISC00 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}

|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem Zeitpunkt bereits wieder das GIE-bit zu setzen, wird dringend davon abgeraten. Dieses wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe, weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.



== Interrupts mit dem AVR GCC Compiler (WinAVR) ==



Funktionen zur Interrupt-Verarbeitung werden in den Includedateien ''interrupt.h'' der avr-libc zur Verfügung gestellt (bei älterem Quellcode zusätzlich ''signal.h'').

<c>
// fuer sei(), cli() und ISR():
#include <avr/interrupt.h>
</c>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status Register gesetzt.

<c>
sei();
</c>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird gelöscht.

<c>
cli();
</c>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf. Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen. Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen Zustands die Interrupts aktivieren, was zu unerwünschten Seiteneffekten führen kann. Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

//...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O" nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern. Dazu ist eine "timed sequence"
einzuhalten (vgl Datenblatt ATmega16, Stand 10/04, S. 229):
Das JTD-Bit muss zweimal innerhalb von 4 Taktzyklen geschrieben
werden. Ein Interrupt zwischen den beiden Schreibzugriffen wuerde
die erforderliche Sequenz "brechen", das JTAG-Interface bliebe
weiterhin aktiv und die IO-Pins weiterhin für JTAG reserviert. */

MCUCSR |= (1<<JTD);
MCUCSR |= (1<<JTD); // 2 mal in Folge ,vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
//...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
//...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichtSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
//...

}
</c>


Zu den aktivierten Interrupts ist eine Funktion zu programmieren, deren Code aufgerufen wird, wenn der betreffende Interrupt auftritt (Interrupt-Handler, Interrupt-Service-Routine). Dazu existiert die Definition (ein Makro) '''ISR'''.

=== ISR ===

(''ISR()'' ersetzt bei neueren Versionen der avr-libc ''SIGNAL()''. SIGNAL sollte nicht mehr genutzt werden, zur Portierung von SIGNAL nach ISR siehe den [[AVR-GCC-Tutorial#Anhang|Anhang]].)

<c>
#include <avr/interrupt.h>
//...
ISR(Vectorname) /* vormals: SIGNAL(siglabel) dabei Vectorname != siglabel ! */
{
/* Interrupt Code */
}
</c>

Mit ''ISR'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektors angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Die Bezeichnung entspricht dem Namen aus dem Datenblatt, bei dem die Leerzeichen durch Unterstriche ersetzt sind und ein ''_vect'' angehängt ist.

Als Beispiel ein Ausschnitt aus der Datei für den ATmega8 (bei WinAVR Standardinstallation in C:\WinAVR\avr\include\avr\iom8.h) in der neben den aktuellen Namen für ''ISR'' (*_vect) noch die Bezeichnungen für das inzwischen nicht mehr aktuelle ''SIGNAL'' (SIG_*) enthalten sind.

<c>
//...
/* $Id: iom8.h,v 1.13 2005/10/30 22:11:23 joerg_wunsch Exp $ */

/* avr/iom8.h - definitions for ATmega8 */
//...

/* Interrupt vectors */

/* External Interrupt Request 0 */
#define INT0_vect _VECTOR(1)
#define SIG_INTERRUPT0 _VECTOR(1)

/* External Interrupt Request 1 */
#define INT1_vect _VECTOR(2)
#define SIG_INTERRUPT1 _VECTOR(2)

/* Timer/Counter2 Compare Match */
#define TIMER2_COMP_vect _VECTOR(3)
#define SIG_OUTPUT_COMPARE2 _VECTOR(3)

/* Timer/Counter2 Overflow */
#define TIMER2_OVF_vect _VECTOR(4)
#define SIG_OVERFLOW2 _VECTOR(4)

/* Timer/Counter1 Capture Event */
#define TIMER1_CAPT_vect _VECTOR(5)
#define SIG_INPUT_CAPTURE1 _VECTOR(5)

/* Timer/Counter1 Compare Match A */
#define TIMER1_COMPA_vect _VECTOR(6)
#define SIG_OUTPUT_COMPARE1A _VECTOR(6)

/* Timer/Counter1 Compare Match B */
#define TIMER1_COMPB_vect _VECTOR(7)
#define SIG_OUTPUT_COMPARE1B _VECTOR(7)

//...
</c>


Mögliche Funktionsrümpfe für Interruptfunktionen sind zum Beispiel:

<c>
#include <avr/interrupt.h>
/* veraltet: #include <avr/signal.h> */

ISR(INT0_vect) /* veraltet: SIGNAL(SIG_INTERRUPT0) */
{
/* Interrupt Code */
}

ISR(TIMER0_OVF_vect) /* veraltet: SIGNAL(SIG_OVERFLOW0) */
{
/* Interrupt Code */
}

ISR(USART_RXC_vect) /* veraltet: SIGNAL(SIG_UART_RECV) */
{
/* Interrupt Code */
}

// und so weiter und so fort...
</c>

Auf die korrekte Schreibweise der Vektorbezeichnung ist zu achten. Der gcc-Compiler prüft erst ab Version 4.x, ob ein Signal/Interrupt der angegebenen Bezeichnung tatsächlich in der Includedatei definiert ist und gibt andernfalls eine Warnung aus. Bei WinAVR (ab 2/2005) wurde die Überprüfung auch in den mitgelieferten Compiler der Version 3.x integriert. Aus dem gcc-Quellcode Version 3.x selbst erstellte Compiler enthalten die Prüfung nicht (vgl. [[AVR-GCC]]).

Während der Ausführung der Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== Unterbrechbare Interruptroutinen ===

"Faustregel": im Zweifel '''ISR'''. Die nachfolgend beschriebene Methode nur dann verwenden, wenn man sich über die unterschiedliche Funktionsweise im Klaren ist.

<c>
#include <avr/interrupt.h>

ISR(XXX,ISR_NOBLOCK) /* veraltet: INTERRUPT(SIG_OVERFLOW0) */
{
/* Interrupt-Code */
}
</c>

Hierbei steht XXX für den oben beschriebenen Namen des Vektors (also z. B. ''TIMER0_OVF_vect''). Der Unterschied im Vergleich zu einer herkömmlichen ISR ist, dass hier beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit durch Einfügen einer SEI-Anweisung direkt wieder gesetzt und somit alle Interrupts zugelassen werden – auch XXX-Interrupts.

Bei unsachgemässer Handhabung kann dies zu erheblichen Problemen wie einem Stack-Overflow oder anderen unerwarteten Effekten führen und sollte wirklich nur dann eingesetzt werden, wenn man sich sicher ist, das Ganze auch im Griff zu haben.

Insbesondere sollte möglichst am ISR-Anfang die auslösende IRQ-Quelle deaktiviert und erst am Ende der ISR wieder aktiviert werden. Robuster als die Verwendung einer NOBLOCK-ISR ist daher folgender ISR-Aufbau:

<c>
#include <avr/interrupt.h>

ISR (XXX)
{
// Implementiere die ISR ohne zunaechst weitere IRQs zuzulassen

<<Dektiviere die XXX-IRQ>>

// Erlaube alle Interrupts (ausser XXX)
sei();

//... Code ...

// IRQs global deaktivieren um die XXX-IRQ wieder gefahrlos
// aktivieren zu koennen
cli();

<<Aktiviere die XXX-IRQ>>
}
</c>
Auf diese Weise kann sich die XXX-IRQ nicht selbst unterbrechen, was zu einer Art Endlosschleife führen würde.

Siehe auch: Hinweise in [[AVR-GCC]]

siehe dazu: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

== Datenaustausch mit Interrupt-Routinen ==

Variablen, die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)) als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte der Compiler den Code so optimieren, dass der Wert der Variablen nur in Prozessorregistern zwischengespeichert wird, die nichts von der Änderung woanders mitbekommen.

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
//...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z. B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt ISR, wird z.B. alle 10ms ausgefuehrt
ISR(TIMER1_COMPA_vect)
{
// hier wird gKeyCounter veraendert. Die übrigen
// Programmteile müssen diese Aenderung "sehen":
// volatile -> aktuellen Wert immer in den Speicher schreiben
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
}
else {
gKeyCounter = 0;
}
}

//...

int main(void)
{
//...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
//...
// hier wird auf gKeyCounter zugegriffen. Dazu muss der in der
// ISR geschriebene Wert bekannt sein:
// volatile -> aktuellen Wert immer aus dem Speicher lesen
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt" */
}
else {
/* hier: Code fuer "Taste kurz gedrueckt" */
}
}
//...
}
</c>

Wird innerhalb einer ISR mehrfach auf eine mit volatile deklarierte Variable zugegriffen, wirkt sich dies ungünstig auf die Verarbeitungsgeschwindigkeit aus, da bei jedem Zugriff mit dem Speicherinhalt abgeglichen wird. Da bei AVR-Controllern ''innerhalb'' einer ISR keine Unterbrechungen zu erwarten sind, bietet es sich an, einen Zwischenspeicher in Form einer lokalen Variable zu verwenden, deren Inhalt zu Beginn und am Ende mit dem der volatile Variable synchronisiert wird. Lokale Variable werden bei eingeschalteter Optimierung mit hoher Wahrscheinlichkeit in Prozessorregistern verwaltet und der Zugriff darauf ist daher nur mit wenigen internen Operationen verbunden. Die ISR aus dem vorherigen Beispiel lässt sich so optimieren:

<c>
//...
ISR(TIMER1_COMPA_vect)
{
uint8_t tmp_kc;

tmp_kc = gKeyCounter; // Uebernahme in lokale Arbeitsvariable

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (tmp_kc < CNTREPEAT) {
tmp_kc++;
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc; // Zurueckschreiben
}
//...
</c>

Zum Vergleich die Disassemblies (Ausschnitte der "lss-Dateien", compiliert für ATmega162) im Anschluss. Man erkennt den viermaligen Zugriff auf die Speicheraddresse von ''gKeyCounter'' (hier 0x032A) in der ISR ohne "Cache"-Variable und den zweimaligen Zugriff in der Variante mit Zwischenspeicher. Im Beispiel ist der Vorteil gering, bei komplexeren Routinen kann die Zwischenspeicherung in lokalen Variablen jedoch zu deutlicheren Verbesserungen führen.

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
876: ca 99 sbic 0x19, 2 ; 25
878: 0a c0 rjmp .+20 ; 0x88e <__vector_13+0x24>
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
87a: 80 91 2a 03 lds r24, 0x032A
87e: 88 3c cpi r24, 0xC8 ; 200
880: 40 f4 brcc .+16 ; 0x892 <__vector_13+0x28>
882: 80 91 2a 03 lds r24, 0x032A
886: 8f 5f subi r24, 0xFF ; 255
888: 80 93 2a 03 sts 0x032A, r24
88c: 02 c0 rjmp .+4 ; 0x892 <__vector_13+0x28>
}
else {
gKeyCounter = 0;
88e: 10 92 2a 03 sts 0x032A, r1
892: 8f 91 pop r24
894: 0f 90 pop r0
896: 0f be out 0x3f, r0 ; 63
898: 0f 90 pop r0
89a: 1f 90 pop r1
89c: 18 95 reti
</pre>

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
uint8_t tmp_kc;

tmp_kc = gKeyCounter;
876: 80 91 2a 03 lds r24, 0x032A

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
87a: ca 9b sbis 0x19, 2 ; 25
87c: 02 c0 rjmp .+4 ; 0x882 <__vector_13+0x18>
87e: 80 e0 ldi r24, 0x00 ; 0
880: 03 c0 rjmp .+6 ; 0x888 <__vector_13+0x1e>
if (tmp_kc < CNTREPEAT) {
882: 88 3c cpi r24, 0xC8 ; 200
884: 08 f4 brcc .+2 ; 0x888 <__vector_13+0x1e>
tmp_kc++;
886: 8f 5f subi r24, 0xFF ; 255
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc;
888: 80 93 2a 03 sts 0x032A, r24
88c: 8f 91 pop r24
88e: 0f 90 pop r0
890: 0f be out 0x3f, r0 ; 63
892: 0f 90 pop r0
894: 1f 90 pop r1
896: 18 95 reti
</pre>

=== volatile und Pointer ===

Bei '''volatile''' in Verbindung mit Pointern ist zu beachten, ob der Pointer selbst oder die Variable, auf die der Pointer zeigt, '''volatile''' ist.

<c>
volatile uint8_t *a; // das Ziel von a ist volatile

uint8_t *volatile a; // a selbst ist volatile
</c>

Falls der Pointer volatile ist (zweiter Fall im Beispiel), ist zu beachten, dass der Wert des Pointers, also eine Speicheradresse, intern in mehr als einem Byte verwaltet wird. Lese- und Schreibzugriffe im Hauptprogramm (außerhalb von Interrupt-Routinen) sind daher so zu implementieren, dass alle Teilbytes der Adresse konsistent bleiben, vgl. dazu den folgenden Abschnitt.

=== Variablen größer 1 Byte ===

Bei Variablen größer ein Byte, auf die in Interrupt-Routinen und im Hauptprogramm zugegriffen wird, muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes außerhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<c>
//...
volatile uint16_t gMyCounter16bit;
//...
ISR(...)
{
//...
gMyCounter16Bit++;
//...
}

int main(void)
{
uint16_t tmpCnt;
//...
// nicht gut: Mglw. hier ein Fehler, wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor dem Kopieren des zweiten Bytes
// ein Interrupt auftritt, der den Inhalt von MyCounter verändert.
tmpCnt = gMyCounter16bit;

// besser: Änderungen "außerhalb" verhindern -> alle "Teilbytes"
// bleiben konsistent
cli(); // Interrupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren

// oder: vorheriger Status des globalen Interrupt-Flags bleibt erhalten
uint8_t sreg_tmp;
sreg_tmp = SREG; /* Sichern */
cli()
tmpCnt = gMyCounter16Bit;
SREG = sreg_tmp; /* Wiederherstellen */

// oder: mehrfach lesen, bis man konsistente Daten hat
uint16_t count1 = gMyCounter16Bit;
uint16_t count2 = gMyCounter16Bit;
while (count1 != count2) {
count1 = count2;
count2 = gMyCounter16Bit;
}
tmpCnt = count1;
//...
}
</c>

Die avr-libc bietet ab Version 1.6.0(?) einige Hilfsfunktionen/Makros, mit der im Beispiel oben gezeigten Funktionalität, die zusätzlich auch sogenannte [http://en.wikipedia.org/wiki/Memory_barrier memory barriers] beinhalten. Diese stehen nach #include <util/atomic.h> zur Verfügung.
<c>
//...
#include <util/atomic.h>
//...

// analog zu cli, Zugriff, sei:
ATOMIC_BLOCK(ATOMIC_FORCEON) {
tmpCnt = gMyCounter16Bit;
}

// oder:

// analog zu Sicherung des SREG, cli, Zugriff und Zurückschreiben des SREG:
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
tmpCnt = gMyCounter16Bit;
}

//...
</c>

* siehe auch [http://www.nongnu.org/avr-libc/user-manual/group__util__atomic.html Dokumentation der avr-libc zu atomic.h]

== Interrupt-Routinen und Registerzugriffe ==

Falls Register sowohl im Hauptprogramm als auch in Interrupt-Routinen verändert werden, ist darauf zu achten, dass diese Zugriffe sich nicht überlappen. Nur wenige Anweisungen lassen sich in sogenannte "atomare" Zugriffe übersetzen, die nicht von Interrupt-Routinen unterbrochen werden können.

Zur Veranschaulichung eine Anweisung, bei der ein Bit und im Anschluss drei Bits in einem Register gesetzt werden:

<c>
#include <avr/io.h>

int main(void)
{
//...
PORTA |= (1<<PA0);

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
//...
}
</c>

Der Compiler übersetzt diese Anweisungen für einen ATmega128 bei Optimierungsstufe "S" nach:

<div class="code"><pre>
...
PORTA |= (1<<PA0);
d2: d8 9a sbi 0x1b, 0 ; 27 (a)

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
d4: 8b b3 in r24, 0x1b ; 27 (b)
d6: 8c 61 ori r24, 0x1C ; 28 (c)
d8: 8b bb out 0x1b, r24 ; 27 (d)
...
</pre></div>

Das Setzen des einzelnen Bits wird bei eingeschalteter Optimierung für Register im unteren Speicherbereich in eine einzige Assembler-Anweisung (sbi) übersetzt und ist nicht anfällig für Unterbrechungen durch Interrupts. Die Anweisung zum Setzen von drei Bits wird jedoch in drei abhängige Assembler-Anweisungen übersetzt und bietet damit zwei "Angriffspunkte" für Unterbrechungen. Eine Interrupt-Routine könnte nach dem Laden des Ausgangszustands in den Zwischenspeicher (hier Register 24) den Wert des Registers ändern, z. B. ein Bit löschen. Damit würde der Zwischenspeicher nicht mehr mit dem tatsächlichen Zustand übereinstimmen aber dennoch nach der Bitoperation (hier ori) in das Register zurückgeschrieben.

Beispiel: PORTA sei anfangs 0b00000000. Die erste Anweisung (a) setzt Bit 0, PORTA ist danach 0b00000001. Nun wird im ersten Teil der zweiten Anweisung der Portzustand in ein Register eingelesen (b). Unmittelbar darauf (vor (c)) "feuert" ein Interrupt, in dessen Interrupt-Routine Bit 0 von PORTA gelöscht wird. Nach Verlassen der Interrupt-Routine hat PORTA den Wert 0b00000000. In den beiden noch folgenden Anweisungen des Hauptprogramms wird nun der zwischengespeicherte "alte" Zustand 0b00000001 mit 0b00011100 logisch-oder-verknüft (c) und das Ergebnis 0b00011101 in PortA geschrieben (d). Obwohl zwischenzeitlich Bit 0 gelöscht wurde, ist es nach (d) wieder gesetzt.

Lösungsmöglichkeiten:
* Register ohne besondere Vorkehrungen nicht in Interruptroutinen ''und'' im Hauptprogramm verändern.
* Interrupts vor Veränderungen in Registern, die auch in ISRs verändert werden, deaktivieren ("cli").
* Bits einzeln löschen oder setzen. sbi und cbi können nicht unterbrochen werden. Vorsicht: nur Register im unteren Speicherbereich sind mittels sbi/cbi ansprechbar. Der Compiler kann nur für diese sbi/cbi-Anweisungen generieren. Für Register außerhalb dieses Adressbereichs ("Memory-Mapped"-Register) werden auch zur Manipulation einzelner Bits abhängige Anweisungen erzeugt (lds,...,sts).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8. (Stand: avr-libc Vers. 1.0.4)

== Interruptflags löschen ==

Beim Löschen von Interruptflags haben AVRs eine Besonderheit, die auch im Datenblatt beschrieben ist: Es wird zum Löschen eine 1 in das betreffende Bit geschrieben.

Hinweis: Dazu '''nicht''' übliche bitweise VerODERung nehmen, sondern eine direkte Zuweisung machen ([http://www.mikrocontroller.net/topic/171148#1640133 Erklärung]).

== Was macht das Hauptprogramm? ==

Im einfachsten (Ausnahme-)Fall gar nichts mehr. Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der main-Funktion lediglich noch die Interrupts aktiviert und dann in einer Endlosschleife verharrt. Sämtliche Funktionen werden dann in den ISRs abgearbeitet. Diese Vorgehensweise ist jedoch bei den meisten Anwendungen schlecht: man verschenkt eine Verarbeitungsebene und hat außerdem möglicherweise Probleme durch Interruptroutinen, die zu viel Verarbeitungszeit benötigen.

Normalerweise wird man in den Interruptroutinen nur die bei Auftreten des jeweiligen Interruptereignisses unbedingt notwendigen Operationen ausführen lassen. Alle weniger kritischen Aufgaben werden dann im Hauptprogramm abgearbeitet.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sogenannten [[Sleep Mode |''Sleep-Modes'']] ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comparators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrupts den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen (eigentlich Makros) der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

;set_sleep_mode (uint8_t mode): Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z. B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
;sleep_enable(): Aktiviert den gesetzten Schlafmodus, versetzt den Controller aber noch nicht in den Schlafmodus
;sleep_cpu(): Versetzt den Controller in den Schlafmodus .sleep_cpu wird im Prinzip durch die Assembler-Anweisung ''sleep'' ersetzt.
;sleep_disable(): Deaktiviert den gesetzten Schlafmodus
;sleep_mode(): Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus. Das Makro entspricht sleep_enable()+sleep_cpu()+sleep_disable(), beinhaltet also nicht die Aktivierung von Interrupts (besser nicht benutzen).

Bei Anwendung von sleep_cpu() müssen Interrupts also bereits freigeben sein (sei()), da der Controller sonst nicht mehr "aufwachen" kann. sleep_mode() ist nicht geeignet für die Verwendung in ISR Interrupt-Service-Routinen, da bei deren Abarbeitung Interrupts global deaktiviert sind und somit auch die möglichen "Aufwachinterrupts". Abhilfe: stattdessen sleep_enable(), sei(), sleep_cpu(), sleep_disable() und evtl. cli() verwenden (vgl. Dokumentation der avr-libc).

<c>
#include <avr/io.h>
#include <avr/sleep.h>

int main(void)
{
...

while (1) {
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach Auftreten eines entsprechenden
// "Aufwach-Interrupts" verarbeitet
...
}
}
</c>

In älteren Versionenen der avr-libc wurden nicht alle AVR-Controller durch die sleep-Funktionen richtig angesteuert. Mit avr-libc 1.2.0 wurde die Anzahl der unterstützten Typen jedoch deutlich erweitert. Bei nicht-unterstützten Typen erreicht man die gewünschte Funktionalität durch direkte "[[Bitmanipulation]]" der entsprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler oder sleep_cpu():

<c>
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 "manuell" aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep"::); // alternativ sleep_cpu() aus sleep.h
...
</c>

== Sleep Modi ==
Zu beachten ist, dass unterschiedliche Prozessoren aus der AVR Familie unterschiedliche Sleep-Modi unterstützen oder nicht unterstützen. Auskunft über die tatsächlichen Gegebenheiten gibt, wie immer, das zum Prozessor gehörende Datenblatt. Die unterschiedlichen Modi unterscheiden sich dadurch, welche Bereiche des Prozessors abgeschaltet werden. Damit korrespondiert unmittelbar welche Möglichkeiten es gibt, den Prozessor aus den jeweiligen Sleep Modus wieder aufzuwecken.

;Idle Mode (SLEEP_MODE_IDLE): Die CPU kann durch SPI, USART, Analog Comperator, ADC, TWI, Timer, Watchdog und irgendeinen anderen Interrupt wieder aufgeweckt werden.

;ADC Noise Reduction Mode (SLEEP_MODE_ADC): In diesem Modus liegt das Hauptaugenmerk darauf, die CPU soweit stillzulegen, dass der ADC möglichst keine Störungen aus dem inneren der CPU auffangen kann. Aufwachen aus diesem Modus kann ausgelöst werden durch den ADC, externe Interrupts, TWI, Timer und Watchdog.

;Power-Down Mode (SLEEP_MODE_PWR_DOWN): In diesem Modus wird ein externer Oszillator (Quarz, Quarzoszillator) gestoppt. Geweckt werden kann die CPU durch einen externen Level Interrupt, TWI, Watchdog, Brown-Out-Reset

;Power-Save-Mode (SLEEP_MODE_PWR_SAVE): Power-Save ist identisch zu Power-Down mit einer Ausnahme: Ist der Timer 2 auf die Verwendung eines externen Taktes konfiguriert, so läuft dieser Timer auch im Power-Save weiter und kann die CPU mit einem Interrupt aufwecken.

;Standby-Mode (SLEEP_MODE_STANDBY, SLEEP_MODE_EXT_STANDBY): Voraussetzung für den Standby-Modus ist die Verwendung eines Quarzes oder eines Quarzoszillators (also einer externen Taktquelle). Ansonsten ist dieser Modus identisch zum Power-Down Modus. Vorteil dieses Modus ist eine kürzere Aufwachzeit.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes
* [http://www.mikrocontroller.net/topic/96369#832712 Forenbeitrag] zur "Nichtverwendung" von sleep_mode in ISRs.

= Zeiger =
Zeiger (engl. ''Pointer'') sind Variablen, die die Adresse von Daten oder Funktionen enthalten und belegen 16 Bits. Die Größe hängt mit dem adressierbaren Speicherbereich zusammen und der GCC reserviert dann den entsprechenden Platz.
Ggf. ist es also günstiger, Indizes auf Arrays (Listen) zu verwenden, so dass der GCC für die Zeigerarithmetik den erforderlichen RAM nur temporär benötigt.

Siehe auch: [[Zeiger]]

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (genauer statisches RAM/SRAM) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als FLASH-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z. B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin selten sinnvoll ist und auch nur bei einigen RAM-losen Typen nach [http://lightner.net/avr/ATtinyAvrGcc.html "Bastelarbeiten"] möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein. Für die Typen ATtiny2313, ATtiny26 und viele weitere der "ATtiny-Reihe" gelten die Ausführungen ebenfalls.

Siehe auch:
* [[Binäre Daten zum Programm hinzufügen]]
== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts Besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

Um Speicher dynamisch (während der Laufzeit) zu reservieren, kann '''malloc()''' verwendet werden. malloc(size) "alloziert" (~reserviert) einen gewissen Speicherblock mit '''size''' Bytes. Ist kein Platz für den neuen Block, wird NULL (0) zurückgegeben.

Wird der angelegte Block zu klein (groß), kann die Größe mit realloc() verändert werden. Den allozierten Speicherbereich kann man mit free() wieder freigeben. Wenn das Freigeben eines Blocks vergessen wird spricht man von einem "Speicherleck" (memory leak).

malloc() legt Speicherblöcke im '''Heap''' an, belegt man zuviel Platz, dann wächst der Heap zu weit nach oben und überschreibt den Stack, und der Controller kommt in Teufels Küche. Das kann leider nicht nur passieren wenn man insgesamt zu viel Speicher anfordert, sondern auch wenn man Blöcke unterschiedlicher Größe in ungünstiger Reihenfolge alloziert/freigibt (siehe Artikel [[Heap-Fragmentierung]]). Aus diesem Grund sollte man malloc() auf Mikrocontrollern sehr sparsam (am besten gar nicht) verwenden.

Beispiel zur Verwendung von malloc():
<c>
#include <stdlib.h>

void foo(void) {
// neuen speicherbereich anlegen,
// platz für 10 uint16
uint16_t* pBuffer = malloc(10 * sizeof(uint16_t));

// darauf zugreifen, als wärs ein gewohnter Buffer
pBuffer[2] = 5;

// Speicher (unbedingt!) wieder freigeben
free(pBuffer);
}
</c>

Wenn (wie in obigem Beispiel) dynamischer Speicher nur für die Dauer einer Funktion benötigt und am Ende wieder freigegeben wird, bietet es sich an, statt malloc() '''alloca()''' zu verwenden. Der Unterschied zu malloc() ist, dass der Speicher auf dem Stack reserviert wird, und beim Verlassen der Funktion automatisch wieder freigegeben wird. Es kann somit kein Speicherleck und keine Fragmentierung entstehen.

siehe auch:
* http://www.nongnu.org/avr-libc/user-manual/malloc.html

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich, um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory, bei AVR Controllern mit mehr als 64kB Flash auch elpm). Die Standard-Laufzeitbibliothek des avr-gcc (die avr-libc) stellt diese Funktionen nach Einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Lokale Variablen (eigentlich Konstanten) innerhalb von Funktionen können ebenfalls im Programmspeicher abgelegt werden. Dazu ist bei der Definition jedoch ein ''static'' voranzustellen, da solche "Variablen" nicht auf dem Stack bzw. (bei Optimierung) in Registern verwaltet werden können. Der Compiler "wirft" eine Warnung falls static fehlt.

<c>
#include <stdint.h>
#include <avr/pgmspace.h>

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Array */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t * const pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t * const pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray2 };

void foo(void)
{
static const uint8_t pgmTestByteLocal PROGMEM = 0x55;
static const char pgmTestStringLocal[] PROGMEM = "im Flash";
// so nicht (static fehlt)
// char pgmTestStringLocalFalsch [] PROGMEM = "so nicht";
}
</c>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<c>
#include <avr/pgmspace.h>

const uint8_t pgmFooByte PROGMEM = 123;
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3, 70 };

void foo (void)
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte (&pgmFooByte);
// myByte hat nun den Wert 123

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (&pgmFooByteArray1[i]);
// mach was mit myByte
}
</c>

=== Wort lesen ===

Für "einfache" 16-Bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion <code>pgm_read_word</code>:

<c>
const uint16_t pgmFooWort PROGMEM = 12345;

uint16_t myWord = pgm_read_word (&pgmFooWort);
</c>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "groß".
Damit ist der mögliche Speicherbereich für "Flash-Konstanten" auf 64kB begrenzt.<ref>Einige avr-libc/pgmspace-Funktionen ermöglichen den Lesezugriff auf den gesamten Flash-Speicher, intern via Assembler Anweisung ELPM. Die Initialisierungswerte des Speicherinhalts jenseits der 64kB-Marke müssen dann jedoch auf anderem Weg angelegt werden, d.h. nicht per PROGMEM; evtl. eigene Section und Linker-Optionen. Alt und nicht ganz korrekt: Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.</ref>

<c>
const uint8_t *ptrToArray;

ptrToArray = (const uint8_t*) pgm_read_word (&pgmPointerToArray1);
// ptrToArray enthält nun die Startadresse des Byte-Arrays pgmFooByteArray1
// Allerdings würde ein direkter Zugriff mit diesem Pointer (z. B. temp=*ptrToArray)
// nicht den Inhalt von pgmFooByteArray1[0] liefern, sondern von einer Speicherstelle
// im RAM, die die gleiche Adresse hat wie pgmFooByteArray1[0]
// Daher muss nun die Funktion pgm_read_byte() benutzt werden, die die in ptrToArray
// enthaltene Adresse benutzt und auf das Flash zugreift.

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (ptrToArray+i);
// mach was mit myByte... (18, 3, 70)
}

ptrToArray = (const uint8_t*) pgm_read_word (&pgmPointerArray[1]);

// ptrToArray enthält nun die Adresse des ersten Elements des Byte-Arrays pgmFooByteArray2
// da im zweiten Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmFooByteArray2 abgelegt ist

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (ptrToArray+i);
// mach was mit myByte... (30, 7, 79)
}
</c>

=== Block lesen ===
In den Standard-Flash Funktionen ist keine der pgm_read_xxxx Nomenklatur folgenden Funktion enthalten, die einen kompletten Block ausliest. Die enstprechende Funktion ist eine Variante von memcpy und heißt memcpy_P().

Was diese Funktion im Prinzip macht, ist einfach in einer Schleife pgm_read_byte zu benutzen, um einen Speicherblock von der Quelladresse im Flash an eine Zieladresse im SRAM zu kopieren.

<c>
void pgm_read_block( uint8_t* pTarget, const uint8_t* pSource, size_t len )
{
size_t i;

for( i = 0; i < len; ++i )
*pTarget++ = pgm_read_byte( pSource++ );
}
</c>

Damit ist es dann natürlich kein Problem mehr ganze Arrays oder Strukturen aus dem Flash in das SRAM zu übertragen.

=== Strings lesen ===
Strings sind in C nichts anderes als eine Abfolge von Zeichen. Der prinzipielle Weg ist daher identisch zu "Bytes lesen", wobei allerdings auf die [http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F Besonderheiten von Strings] wie 0-Terminierung geachtet werden muss, bzw. diese zur Steuerung einer Schleife über die Zeichen im String ausgenutzt werden kann

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hello world";

int main()
{
char c;
const char* addr;

addr = pgmString;
while (c = pgm_read_byte (addr++), c != '\0')
{
// mach was mit c
}
}
</c>

Zur Unterstützung des Programmierers steht das Repertoir der str-Funktionen auch in jeweils eine Variante zur Verfügung, die mit dem Flash-Speicher arbeiten kann. Die Funktionsnamen tragen den Suffix <tt>_P</tt>.

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hallo world";

void foo (void)
{
char string[40];

strcpy_P (string, pgmString);
}
</c>

=== Float lesen ===

Auch um floats zu lesen gibt es ein Makro:

<c>
float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};

void read_float (void)
{
int i;
float f;

for (i=0; i<3; i++)
{
// entspricht f = pgmFloatArray[i];
f = pgm_read_float (&pgmFloatArray[i]);
// mach was mit f
}
}
</c>

TODO: Beispiele für structs und pointer aus Flash auf struct im Flash (menues, state-machines etc.). Eine kleine Einleitung insbesondere auch in Bezug auf die auftretenden Schwierigkeiten liefert [http://www.mail-archive.com/avr-gcc-list@nongnu.org/msg05652.html].

=== Array aus Strings im Flash-Speicher ===

Arrays aus Strings im Flash-Speicher werden in zwei Schritten angelegt: Zuerst die einzelnen Elemente des Arrays und im Anschluss ein Array, in dem die Startaddressen der Strings abgelegt werden. Zum Auslesen wird zuerst die Adresse des i-ten Elements aus dem Array im Flash-Speicher gelesen, die im Anschluss dazu genutzt wird, auf das Element (den String) selbst zuzugreifen.

<c>
#include <stdint.h>
#include <avr/pgmspace.h>

const char str1[] PROGMEM = "first_A";
const char str2[] PROGMEM = "second_A";
const char str3[] PROGMEM = "third_A";

const char * const strarray1[] PROGMEM =
{
str1,
str2,
str3
};

static char work[20];

void read_strings (void)
{
size_t i;

for (i = 0; i < sizeof (strarray1) / sizeof (strarray1[0]); i++)
{
size_t j, len;

// setze Pointer auf die Addresse des i-ten Elements des
// Flash-Arrays (str1, str2, ...)
const char *pstrflash = (const char*) pgm_read_word (&strarray1[i]);

// kopiere den Inhalt der Zeichenkette von der
// in pstrflash abgelegten Adresse in das work-Array
// analog zu strcpy( work, strarray1[i]) wenn alles im RAM
strcpy_P (work, pstrflash);

// Gleichbedeutend damit:
strcpy_P (work, (const char*) pgm_read_word (&strarray1[i]));

// Zeichen-fuer-Zeichen
len = strlen_P (&strarray1[i]);

// <= da auch das Stringende-Zeichen kopiert werden soll
for (j = 0; j <= len; j++)
{
// analog zu work[j] = strarray[i][j] wenn alles im RAM
work[i] = (char) pgm_read_byte (pstrflash++);
}
}
}
</c>

Siehe dazu auch die avr-libc FAQ: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_rom_array How do I put an array of strings completely in ROM?]

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<c>
#include <string.h>
#include <avr/pgmspace.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann";
char StringImRam[MAXLEN];

void read_string (void)
{
strcpy (StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P (StringImRam, StringImFlash, 5))
{
// mach was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else
{
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P (StringImRam, PSTR("Mueller-Schmitt"), 5))
{
// der Code hier wird ausgefuehrt, wenn die ersten
// 5 Zeichen uebereinstimmen
}
else
{
// wird bei Nicht-Uebereinstimmung ausgefuehrt
}
}
</c>

Aber Vorsicht: Ersetzt man zum Beispiel
<c>
// Daten im "Flash"
const char flashText[] PROGMEM = "mit[]";
</c>
durch
<c>
// Hier wird "mit*" im RAM angelegt und flashPointer
// enthaelt die Adresse
const char* const flashPointer PROGMEM = "mit*";
</c>
dann kann es zu Problemen kommen.

Übergibt man Zeichenketten, die im Flash abglegt sind an eine Funktion – also die Adresse des ersten Zeichens – so muss die Funktion entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden, ob es sich um eine Flash-Adresse oder ein RAM-Adresse handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen, die Flash-Adressen erwarten, mit dem Suffix <code>_P</code> versehen sind.

Eine Funktion, die einen im Flash abgelegten String z. B. an eine UART ausgibt, würde dann so aussehen:

<c>
void uart_puts_p (const char *text)
{
char zeichen;

while ((zeichen = pgm_read_byte (text)))
{
// so lange, wie mittels pgm_read_byte nicht das Stringende
// gelesen wurde: gib dieses Zeichen aus

uart_putc (zeichen);
text++;
}
}
</c>

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<c>
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
extern void lcd_puts_p (const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))

// in einer Anwendung
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

const char StringImFlash[] PROGMEM = "Erwin Lindemann";

void my_write (coid)
{
lcd_puts_p (StringImFlash);
lcd_puts_P ("Dr. Kloebner");
}</c>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option – auch bekannt als [[Bootloader]]-Support – können Teile des Flash-Speichers vom Anwendungsprogramm beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktion in einem besonderen Speicherbereich, der boot-section des Programmspeichers/Flash, abgelegt ist.

Bei einigen kleinen AVRs gibt es keine gesonderte Boot-Section, bei diesen kann der Flashspeicher von jeder Stelle des Programms geschrieben werden. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

Siehe auch:
* Forumsbeitrag [http://www.mikrocontroller.net/topic/163632#1561622 Daten in Programmspeicher speichern]

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so kompliziert ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.

Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette, z. B. 0x01fe, weiß die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert, also dem Zahlenwert, kann nicht auf den Ort der Ablage geschlossen werden.

Einige AVR-Compiler bilden die Harvard-Architektur ab, indem sie in einen Pointer nicht nur die Adresse speichern, sondern auch den Ablageort wie ''Flash'' oder ''RAM''. In einem Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch auch Nachteile, denn bei jedem Zugriff über einen Zeiger muss zur ''Laufzeit'' entschieden werden, wie der Zugriff auszuführen ist und entsprechend länglicher und langsamer kann Code ausgeführt werden.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z. B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmäßig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, dass vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgegeben sind, die innerhalb weniger Taktzyklen aufeinanderfolgen müssen ("timed sequence"). Auch dies muss bei Nutzung der Funktionen aus der avr-libc/eeprom.h-Datei nicht selbst implementiert werden. Innerhalb der Funktionen werden Interrupts vor der "EEPROM-Sequenz" global deaktiviert und im Anschluss, falls vorher auch schon eingeschaltet, wieder aktiviert.

Um eine Variable im EEPROM anzulegen, stellt die avr-libc das Makro EEMEM zur Verfügung<ref>In älteren Versionen der avr-libc ist EEMEM noch nicht vorhanden, und man kann sich folgendermassen behelfen:
<c>
#include <avr/eeprom.h>

#ifndef EEMEM
#define EEMEM __attribute__((section (".eeprom")))
#endif
</c></ref>, das analog zu PROGMEM verwendet wird.

<c>
#include <stdint.h>
#include <avr/eeprom.h>

/* Byte */
uint8_t eeFooByte EEMEM = 123;

/* Wort */
uint16_t eeFooWord EEMEM = 12345;

/* float */
float eeFooFloat EEMEM;

/* Byte-Array */
uint8_t eeFooByteArray1[] EEMEM = { 18, 3, 70 };
uint8_t eeFooByteArray2[] EEMEM = { 30, 7, 79 };

/* 16-bit unsigned short feld */
uint16_t eeFooWordArray1[4] EEMEM;
</c>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heißt eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<c>
#define EEPROM_DEF 0xFF

void eeprom_example (void)
{
uint8_t myByte;

// myByte lesen (Wert = 123)
myByte = eeprom_read_byte (&eeFooByte);

// der Wert 99 wird im EEPROM an die Adresse der
// Variablen eeFooByte geschrieben
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben

myByte = eeprom_read_byte (&eeFooByteArray1[1]);
// myByte hat nun den Wert 3

// Beispiel zur "Sicherung" gegen leeres EEPROM nach "Chip Erase"
// (z. B. wenn die .eep-Datei nach Programmierung einer neuen Version
// des Programms nicht in den EEPROM uebertragen wurde und EESAVE
// deaktiviert ist (unprogrammed/1)
//
// Vorsicht: wenn EESAVE "programmed" ist, hilft diese Sicherung nicht
// weiter, da die Speicheraddressen in einem neuen/erweiterten Programm
// moeglicherweise verschoben wurden. An der Stelle &eeFooByte steht
// dann u.U. der Wert einer anderen Variable aus einer "alten" Version.

uint8_t fooByteDefault = 222;
if ((myByte = eeprom_read_byte (&eeFooByte)) == EEPROM_DEF)
{
myByte = fooByteDefault;
}
}
</c>

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<c>
// lesen
uint16_t myWord = eeprom_read_word (&eeFooWord);

// schreiben
eeprom_write_word (&eeFooWord, 2222);
</c>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen <code>eeprom_read_block()</code> bzw. <code>eeprom_write_block()</code>. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes als <code>size_t</code>.
<c>
uint8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

void eeprom_block_example (void)
{
/* Datenblock aus EEPROM lesen */

/* liest 3 Bytes ab der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block (myByteBuffer, eeFooByteArray1, 3);

/* dito mit etwas Absicherung betr. der Länge */
eeprom_read_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer));

/* und nun mit 16-Bit Array */
eeprom_read_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer));

/* Datenblock in EEPROM schreiben */
eeprom_write_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer));
eeprom_write_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer));
}
</c>

Ebenso lassen sich float-Variablen lesen und schreiben:

<c>
#include <avr/eeprom.h>

float eeFloat EEMEM = 12.34f;

float void eeprom_float_example (float value)
{
/* float in EEPROM schreiben */
eeprom_write_float (&eeFloat, value);

/* float aus EEPROM lesen */
return eeprom_read_float (&eeFloat);
}</c>

=== EEPROM-Speicherabbild in .eep-Datei ===

Mit den zum Compiler gehörenden Werkzeugen kann der aus den Variablendeklarationen abgeleitete EEPROM-Inhalt in eine Datei geschrieben werden. Die übliche Dateiendung ist .eep, Daten im Intel Hex-Format. Damit können Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden.

Makefiles nach WinAVR/MFile-Vorlage enthalten bereits die notwendigen Einstellungen, siehe dazu die Erläuterungen im [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]].

Der Inhalt der eep-Datei muss ebenfalls zum Mikrocontroller übertragen werden, wenn die Initialisierungswerte aus der Deklaration vom Programm erwartet werden. Ansonsten enthält der EEPROM-Speicher nach der Übertragung des Programmers mittels ISP abhängig von der Einstellung der EESAVE-Fuse<ref>vgl. Datenblatt Abschnitt Fuse Bits</ref> nicht die korrekten Werte:
; EESAVE = 0 (programmed): Die Daten im EEPROM bleiben erhalten. Werden sie nicht neu geschrieben, so enthält das EEPROM evtl. Daten, die nicht mehr zum Programm passen.
; EESAVE = 1 (unprogrammed): Beim Programmieren werden die Daten im EEPROM gelöscht, also auf 0xff gesetzt.

Als Sicherung kann man im Programm nochmals die Standardwerte vorhalten, beim Lesen auf 0xFF prüfen und gegebenenfalls einen Standardwert nutzen.

=== Direkter Zugriff auf EEPROM-Adressen ===

Will man direkt auf bestimmte EEPROM Adressen zugreifen, dann sind folgende Funktionen hilfreich, um sich die Typecasts zu ersparen:

<c>
#include <avr/eeprom.h>

// Byte aus dem EEPROM lesen
uint8_t EEPReadByte(uint16_t addr)
{
return eeprom_read_byte((uint8_t *)addr);
}

// Byte in das EEPROM schreiben
void EEPWriteByte(uint16_t addr, uint8_t val)
{
eeprom_write_byte((uint8_t *)addr, val);
}
</c>

oder als Makro:

<c>
#define EEPReadByte(addr) eeprom_read_byte((uint8_t *)addr)
#define EEPWriteByte(addr, val) eeprom_write_byte((uint8_t *)addr, val)
</c>

Verwendung:

<c>
EEPWriteByte(0x20, 128); // Byte an die Adresse 0x20 schreiben
...
Val=EEPReadByte(0x20); // EEPROM-Wert von Adresse 0x20 lesen
</c>

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Bei alten Versionen der avr-libc wurden nicht alle AVR Controller unterstützt. Z.B. bei der avr-libc Version 1.2.3 insbesondere bei AVRs "der neuen Generation" (ATmega48/88/168/169) funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register). In neueren Versionen (z. B. avr-libc 1.4.3 aus WinAVR 20050125) wurde die Zahl der unterstüzten Controller deutlich erweitert und eine Methode zur leichten Anpassung an zukünftige Controller eingeführt.

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Will oder kann man nicht auf die neue Version aktualisieren, kann der dort gezeigte Code auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste", gegebenfalls Schutz vor Unterbrechnung/Interrupt ergänzen ''uint8_t sreg; sreg=SREG; cli(); [EEPROM-Code] ; SREG=sreg; return;'', siehe Abschnitt Interrupts). Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

=== EEPROM Register ===
Um das EEPROM anzusteuern, sind drei Register von Bedeutung:
;EEAR: Hier werden die Adressen eingetragen zum Schreiben oder Lesen. Dieses Register unterteilt sich nochmal in EEARH und EEARL, da in einem 8-Bit-Register keine 512 Adressen adressiert werden können.
;EEDR: Hier werden die Daten eingetragen, die geschrieben werden sollen, bzw. es enthält die gelesenen Daten.
;EECR: Ist das Kontrollregister für das EEPROM

Das EECR steuert den Zugriff auf das EEPROM und ist wie folgt aufgebaut:

:{| class="wikitable" style="text-align:center"
|+ '''Aufbau des EECR-Registers'''
|-
!Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| - || - || - ||- || EERIE || EEMWE || EEWE || EERE
|-
! Read/Write
| R || R || R || R || R/W || R/W || R/W || R/W
|-
!Init Value
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''Bedeutung der Bits'''

;Bit 4-7: nicht belegt

;Bit 3 (EERIE): ''EEPROM Ready Interrupt Enable'': Wenn das Bit gesetzt ist und globale Interrupts erlaubt sind in Register SREG (Bit 7), wird ein Interrupt ausgelöst nach Beendigung des Schreibzyklus (EEPROM Ready Interrupt). Ist einer der beiden Bits 0, wird kein Interrupt ausgelöst.

;Bit 2 EEMWE): ''EEPROM Master Write Enable'': Dieses Bit bestimmt, dass, wenn EEWE = 1 gesetzt wird (innerhalb von 4 Taktzyklen), das EEPROM beschrieben wird mit den Daten in EEDR bei Adresse EEAR. Wenn EEMWE = 0 ist und EEWE = 1 gesetzt wird, hat das keine Auswirkungen. Der Schreibvorgang wird dann nicht ausgelöst. Nach 4 Taktzyklen wird das Bit EEMWE automatisch wieder auf 0 gesetzt. Dieses Bit löst den Schreibvorgang nicht aus, es dient sozusagen als Sicherungsbit für EEWE.

;Bit 1 (EEWE): ''EEPROM Write Enable'': Dieses Bit löst den Schreibvorgang aus, wenn es auf 1 gesetzt wird, sofern vorher EEMWE gesetzt wurde und seitdem nicht mehr als 4 Taktzyklen vergangen sind. Wenn der Schreibvorgang abgeschlossen ist, wird dieses Bit automatisch wieder auf 0 gesetzt und, sofern EERIE gesetzt ist, ein Interrupt ausgelöst. Ein Schreibvorgang sieht typischerweise wie folgt aus:
:# EEPROM-Bereitschaft abwarten (EEWE=0)
:# Adresse übergeben an EEAR
:# Daten übergeben an EEDR
:# Schreibvorgang auslösen in EECR mit Bit EEMWE=1 und EEWE=1
:# (Optional) Warten, bis Schreibvorgang abgeschlossen ist

;Bit 0 EERE: ''EEPROM Read Enable'': Wird dieses Bit auf 1 gesetzt wird das EEPROM an der Adresse in EEAR ausgelesen und die Daten in EEDR gespeichert. Das EEPROM kann nicht ausgelesen werden, wenn bereits eine Schreiboperation gestartet wurde. Es ist daher zu empfehlen, die Bereitschaft vorher zu prüfen. Das EEPROM ist lesebereit, wenn das Bit EEWE=0 ist. Ist der Lesevorgang abgeschlossen, wird das Bit wieder auf 0 gesetzt, und das EEPROM ist für neue Lese- und Schreibbefehle wieder bereit. Ein typischer Lesevorgang kann wie folgt aufgebaut sein:
:# Bereitschaft zum Lesen prüfen (EEWE=0)
:# Adresse übergeben an EEAR
:# Lesezyklus auslösen mit EERE = 1
:# Warten, bis Lesevorgang abgeschlossen EERE = 0
:# Daten abholen aus EEDR

= Die Nutzung von sprintf und printf =

Um komfortabel, d.h. formatiert, Ausgaben auf ein Display oder die serielle Schnittstelle zu tätigen, bieten sich '''sprintf''' oder '''printf''' an. Alle *printf-Varianten sind jedoch ziemlich speicherintensiv und der Einsatz in einem Mikrocontroller mit knappem Speicher muss sorgsam abgewogen werden.

Bei '''sprintf''' wird die Ausgabe zunächst in einem Puffer vorbereitet und anschließend mit einfachen Funktionen zeichenweise ausgegeben. Es liegt in der Verantwortung des Programmierers, genügend Platz im Puffer für die erwarteten Zeichen bereitzuhalten.

<c>
#include <stdio.h>
#include <stdint.h>

// ...
// nicht dargestellt: Implementierung von uart_puts (vgl. Abschnitt UART)
// ...

uint16_t counter;

// Ausgabe eines unsigned Integerwertes
void uart_puti( uint16_t value )
{
uint8_t puffer[20];

sprintf( puffer, "Zählerstand: %u", value );
uart_puts( puffer );
}

int main()
{
counter = 5;

uart_puti( counter );
uart_puti( 42 );
}
</c>

Eine weitere elegante Möglichkeit besteht darin, den STREAM stdout (Standardausgabe) auf eine eigene Ausgabefunktion umzuleiten. Dazu wird dem Ausgabemechanismus der C-Bibliothek eine neue Ausgabefunktion bekannt gemacht, deren Aufgabe es ist, ein einzelnes Zeichen auszugeben. Wohin die Ausgabe dann tatsächlich stattfindet, ist Sache der Ausgabefunktion. Im Beispiel unten wird auf UART ausgegeben. Alle anderen, höheren Funktionen wie z. B. '''printf''', greifen letztendlich auf diese primitive Ausgabefunktion zurück.

<c>
#include <avr/io.h>
#include <stdio.h>

void uart_init(void);

// a. Deklaration der primitiven Ausgabefunktion
int uart_putchar(char c, FILE *stream);

// b. Umleiten der Standardausgabe stdout (Teil 1)
static FILE mystdout = FDEV_SETUP_STREAM( uart_putchar, NULL, _FDEV_SETUP_WRITE );

// c. Definition der Ausgabefunktion
int uart_putchar( char c, FILE *stream )
{
if( c == '\n' )
uart_putchar( '\r', stream );

loop_until_bit_is_set( UCSRA, UDRE );
UDR = c;
return 0;
}

void uart_init(void)
{
/* hier µC spezifischen Code zur Initialisierung */
/* des UART einfügen... s.o. im AVR-GCC-Tutorial */

// Beispiel:
//
// myAVR Board 1.5 mit externem Quarz Q1 3,6864 MHz
// 9600 Baud 8N1

#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

// Hilfsmakro zur UBRR-Berechnung ("Formel" laut Datenblatt)
#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)

UCSRB |= (1<<TXEN) | (1<<RXEN); // UART TX und RX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); // Asynchron 8N1

UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );
UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );
}

int main(void)
{
int16_t antwort = 42;
uart_init();

// b. Umleiten der Standardausgabe stdout (Teil 2)
stdout = &mystdout;

// Anwendung
printf( "Die Antwort ist %d.\n", antwort );
return 0;
}

// Quelle: avr-libc-user-manual-1.4.3.pdf, S.74
// + Ergänzungen
</c>

Sollen Fließkommazahlen ausgegeben werden, muss im Makefile eine andere (größere) Version der [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|printflib]] eingebunden werden.

= Anmerkungen =
<references/>

= TODO =
* Aktualisierung Register- und Bitbeschreibungen an aktuelle AVR
* "naked"-Funktionen

[[Kategorie:avr-gcc Tutorial| ]]

ARM Cortex Mikrocontroller

2012-04-21T20:14:56Z

Mthomas:

Die Firma ARM stellt selbst keine Prozessoren/Controller her, sondern entwickelt nur sogenannte "IP-Cores", die von Herstellern wie Atmel, Philips, TI und vielen anderen lizenziert werden. Diese Hersteller ergänzen den Core um Speicher und Peripherie. Der Vorteil dieses Modells ist, dass dadurch sehr viele Prozessoren mit unterschiedlichster Ausstattung verfügbar sind, die alle mit dem selben Befehlssatz (und damit dem selben Compiler) programmierbar sind.

Allen ARM-Cores gemeinsam ist die 32 Bit RISC-Architektur. Manche ARM-Cores besitzen neben dem 32 Bit ARM-Befehlssatz noch einen zusätzlichen, kleineren 16 Bit-Befehlssatz ('''Thumb'''-Modus, erkennbar am '''T''' in der Bezeichnung, z. B. ARM7'''T'''DMI). Der Vorteil des Thumb-Befehlssatzes ist der geringere Platzbedarf des Codes; der Nachteil ist die etwas niedrigere Geschwindigkeit. Die ARMv7M-Architektur (man beachtet das '''v'''), also z. B. Controller mit Cortex-M3-Kern, unterstützen ausschließlich den Thumb2-Befehlssatz.

Seit wenigen Jahren sind ARM-basierte Mikrocontroller erhältlich, die Aufgrund der vergleichbar einfachen Beschaltung und mit einer '''deutlich''' größeren Power eine echte Alternative zu 8-Bit-Controllern darstellen.

Eine sehr aktuelle Variante des ARM ist die Cortex-M3 Familie die '''[[LPC1xxx]]''', als eine echte Konkurrenz zu 8- und 16-Bit Mikrocontrollern wie dem [[AVR]] und [[MSP430]] gedacht ist. Der Cortex-M3 enthält einige Verbesserungen gegenüber dem ARM7TDMI-Kern und ist bereits dabei diesen zu ersetzen. Um den Einstieg zu erleichtern ist für den LPC1xxx bereits eine '''[http://www.mikrocontroller.net/articles/Codebase_f%C3%BCr_LPC1xxx#Allgemeine_Informationen_zum_Aufbau_der_Code_Base Code-Base]''' und ein preisgünstiges '''[http://www.mikrocontroller.net/wikisoftware/index.php?title=LPC1xxx_Entwicklungskit_LPCXpresso&action=edit Entwicklungskit]''' vorhanden. Controllerfamilien dieser Klasse sind:

* [http://www.nxp.com LPC13xx/LPC17xx] von NXP oder die inzwischen schon sehr ausführliche, [http://www.mikrocontroller.net/articles/LPC1xxx '''interne Seite zur Cortex-M3 Familie''' von LPC]
* [http://focus.ti.com/general/docs/gencontent.tsp?contentId=54556&DCMP=Luminary&HQS=Other+OT+stellaris Stellaris-Serie] von [http://www.ti.com Texas Instruments] (vormals Luminary Micro)
* [http://www.atmel.com/products/at91/sam3landing.asp?family_id=605 AT91SAM3] von Atmel
* [[STM32]] von STMicroelectronics
* [http://www.toshiba-components.com/microcontroller/TMPM330.html TMPM330] von Toshiba
* [http://www.fujitsu.com/global/services/microelectronics/product/micom/roadmap/industrial/fm3/ FM3-Serie] von Fujitsu
* [http://www.energymicro.com/ EFM32-Serie] von Energy Micro
* [http://www.infineon.com/XMC4000 XMC4000] von Infineon
* [https://www.silabs.com/products/mcu/Pages/ARM-32bit-microcontroller.aspx SiM3U1xx] von Silabs
* [http://www.holtek.com.tw/english/products/32bit_flashmcu.htm HT32] von Holtek Semiconductor

Als günstigere Variante gibt es dann noch die Cortex-M0 Cores. Diese
werden beispielsweise in folgenden Controllern eingesetzt:

* [http://ics.nxp.com/products/lpc1000/lpc11xx/ LPC11xx] von [http://www.nxp.com NXP]
* [http://www.nuvoton.com/hq/enu/ProductAndSales/ProductLines/IndustrialIC/ARMMicrocontroller/ARMCortexTMM0/Pages/default.aspx NuMicro-Controller] von nuvoton (ex Winbond), laut Datenblatt mit 2.5-5.5V Betriebssspannung!!!

Eine schon etwas ältere Controller-Familie ist der '''ARM7'''TDMI. Core. Controllerfamilien dieser Klasse sind:
* NXP (ehemals Philips) [[LPC2000]]
* Atmel [[AT91SAM]]7
* Analog Devices [[ADuC7xxx]]
* [http://focus.ti.com/mcu/docs/mcuprodoverview.tsp?sectionId=95&tabId=203&familyId=454 Texas Instruments TMS470]
* SAMSUNG S3C24x0 [http://www.samsung.com/global/business/semiconductor/productInfo.do?fmly_id=229&partnum=S3C2410]
* STR7xx von ST Microelectronics [http://www.st.com/mcu/inchtml-pages-str7.html]
* und viele weitere

Mehr Informationen zur ARM-Architektur finden sich in der [http://de.wikipedia.org/wiki/ARM-Architektur Wikipedia], weiterführende Links in der [[Linksammlung#ARM|Linksammlung]].

== Compiler ==

Einer der beliebtesten Compiler für ARM-Prozessoren ist der GCC. Er kann sowohl ARM- als auch Thumb-Code erzeugen. Ein komplettes Paket mit allen benötigten Tools für Windows ist [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/#winarm WinARM] (wird derzeit nicht gepflegt), für Linux und Mac OS X gibt es fertige Komplettpakete [http://www.mikrocontroller.net/en/arm-gcc hier]. Alternative Pakete sind [http://gnuarm.com/ GNUARM] (Linux, Windows, wird derzeit nicht gepflegt), [http://www.yagarto.de/ Yagarto] (Windows, mit Eclipse-Integration), [http://www.codesourcery.com/gnu_toolchains/arm CodeSourcery CodeBench Lite] (alter Name: Codesourcery G++ lite, für Linux, Windows) und [https://launchpad.net/gcc-arm-embedded GNU Tools for ARM Embedded Processors] (bereitgestellt auf launchpad.net).

Inzwischen schon weiter verbreitet ist auch das '''kostenlose''' auf Eclipse basierende Entwicklungspaket von [http://www.code-red-tech.com/red-suite-4-nxp.php '''Code-Red'''] oder [http://www.coocox.org/CooCox_CoIDE.htm '''CooCox IDE''']

Kommerzielle Entwicklungsumgebungen für ARM-basierte Mikrocontroller sind z. B. [http://rowley.co.uk/arm/ Crossworks ARM] (GCC-basiert, Windows, Mac OS und Linux), [http://www.iar.com/ewarm/ IAR Embedded Workbench for ARM] (Windows) und [http://www.keil.com/arm/ MDK-ARM von Keil/ARM] (Windows).

Für das MBED Board (mbed NXP LPC1768) ist ein kostenloser Onlinecompiler verfügbar (ARM Realview), der sich durch die Bereitstellung von sehr leistungsfähigen Funktionen (API's) auszeichnet. Den praktischen Nutzen für eine professionelle Anwendung mag man zu Recht in Frage stellen. Um mal schnell was zu programmieren ist das Ding unschlagbar, es ist faktisch keine Installation oder Einarbeitung in eine IDE nötig.

== JTAG ==

Alle ARM-basierten Prozessoren verwenden ein einheitliches [[JTAG]]-Interface, über das Debugging und Speicherzugriff erfolgen kann. Nicht standardisiert sind allerdings die Verfahren zum Beschreiben des Flash-ROMs, deshalb muss man beachten ob die verwendete JTAG-Software Programmierroutinen für den jeweiligen Controller besitzt.

Ein einfacher JTAG-Adapter für den Parallelport ist der "Wiggler"-kompatible, den man selbst bauen kann oder z. B. im [http://shop.embedded-projects.net/index.php?module=artikel&action=artikel&id=48 Embedded Projects Shop] für € 10,00 bestellen kann. Als Software lässt sich unter Windows und Linux [http://openocd.berlios.de/ OpenOCD] (zusammen mit [[GDB]]) oder [http://rowley.co.uk Crossworks ARM] verwenden.

Für USB gibt es [http://shop.embedded-projects.net/index.php?module=artikel&action=artikel&id=436 hier] einen ebenfalls OpenOCD-kompatiblen JTAG-Adapter zum Preis von ca 45€.

Von NXP sind sehr preiswerte Entwicklungskits (ca. 25€ für Evaluation-Board incl. USB-JTAG Programmer und Debugger) erhältlich z.B. '''[http://www.watterott.com/index.php?page=search&keywords=LPCXpresso&cat=&mnf=&x=0&y=0 Watterott]'''. Siehe dazu auch die Dokumentation von NXP zu den '''[http://www.nxp.com/documents/leaflet/75016842.pdf LPCXpresso-Entwicklungskits]''' (PDF), oder diese '''[http://www.mikrocontroller.net/wikisoftware/index.php?title=LPC1xxx_Entwicklungskit_LPCXpresso Beschreibung]'''.

Der [http://www.segger.com/cms/jlink.html J-Link]-"Emulator" von Segger wird von vielen Softwarepaketen unterstützt und ist für den nicht-kommerziellen Einsatz zu günstigen Konditionen erhältlich.

Als Alternative zum Beschreiben des Flash über JTAG ist oft ein serieller [[Bootloader]] im Controller enthalten.

== Freie Software ==

=== ARM/XSCALE/CORTEX Instruction Set Simulator ===

Die Firma Lauterbach bietet unter der Artikelnummer LA-8809 einen Instruction Set Simulator für ARM Cores an. Die Demoversion ist zur Evaluierung kostenlos. Einschränkungen bestehen in der Anzahl der zu ladenen Debugsymbole. Der Simulator unterstützt alle gängigen ARM Derivate und lädt alle üblichen Debugformate, wie die des RealView, IAR und TI Compilers, oder der freien GCC Tools.

Zum Simulator gibt es entsprechende zugehörige Debugtools, die allerdings käuflich zu erwerben sind.

Weblinks:
[[http://www.lauterbach.com/frames.html?dwnload.html Download area mit ARM/XSCALE/CORTEX Simulator]]

== Siehe auch ==
* [[Linksammlung#ARM|Linksammlung (Abschnitt ARM)]]
* [http://www.mikrocontroller.net/articles/LPC1xxx Beschreibung der LPC1xxx-Familie]
* [http://www.mikrocontroller.net/articles/LPC1xxx_Entwicklungskit_LPCXpresso LPCXpresso-Entwicklungskit]
* [http://www.mikrocontroller.net/articles/Installationsanleitung_C-Entwicklungsumgebung_f%C3%BCr_LPC1xxx_von_Code_Red Installationsanleitung zur IDE von Code-Red]
* [http://www.mikrocontroller.net/articles/Codebase_f%C3%BCr_LPC1xxx LPC1xxx Codebase]
* [[ARM-elf-GCC-Tutorial]]
* [[AVR32]]
* [[Blackfin]]
* [[AT91SAM9260]]
* [[STM32]]
* [[JTAG]]

== Weblinks ==
* [http://embdev.net/forum/arm-gcc ARM-GCC Forum] im englischsprachigen "Ableger" von microcontroller.net embdev.net u.a. für WinARM, Yagarto, CS Codebench
* [http://infocenter.arm.com/help/index.jsp Infocenter von ARM Ltd.]
* [http://www.open-research.org.uk/ARMuC/ ARMuC ARM microcontroller Wiki]
* [http://chaosradio.ccc.de/cre151.html Chaosradio Express - Die ARM-Architektur]

== Literatur ==
*ARM Systems Developer's Guide (2004) ISBN 1558608745 [http://books.google.de/books?id=HKKUkDQE17QC&output=html Im Buch blättern] [http://www.mkp.com/companions/defaultindividual.asp?isbn=9781558608740 Programmbeispiele aus dem Buch, u.a. FFT, FIR/IIR-Filter, Division, Wurzel]
*ARM Assembly Language - an Introduction (2007) ISBN 1847536964 [http://books.google.de/books?id=8KJX5R8mMvsC&output=html Im Buch blättern] [http://www.lulu.com/content/1172076 Verlagsseite "Book on demand"]
*ARM Rechnerarchitekturen für System-on-Chip-Design (2002) ISBN 3826608542
*Co-Verification of Hardware and Software for Arm Soc Design (2004) ISBN 0750677309
*ARM System-on-Chip Architecture (2000) ISBN 0201675196 [http://books.google.de/books?id=J_Fu_YTVD9gC&printsec=frontcover&output=html&source=gbs_summary_r&cad=0 Im Buch blättern]
*ARM Architecture Reference Manual ISBN 0201737191 [http://books.google.de/books?id=O5G-6WX1xWsC&printsec=frontcover&output=html&source=gbs_summary_r&cad=0 Im Buch blättern]
*Messen, Steuern und Regeln mit ARM-Mikrocontrollern ISBN 3772340172 [http://books.google.de/books?id=TKs4kN-zNYQC&output=html im Buch blättern]
*Programming Arm Microcontrollers: Using C and the Lpc2100 Family (2005? /ab 1. Dezember 2008) ISBN 0321263359
*Arm Assembly: Fundamentals and Techniques (ab 1. März 2009) ISBN 1439806101
*Reliable Embedded Systems: Using 8051 and ARM Microcontrollers (2007) ISBN 0321252918 600 Seiten mit CD [http://vig.pearsoned.co.uk/catalog/academic/product/0,1144,0321252918-TOC,00.html Inhaltsverzeichnis]
* C und C++ für Embedded Systems (u.a. ARM Cortex-M3) mitp-Verlag 2008 ISBN 382665949X

== Artikel aus der Kategorie ARM ==
<ncl style=compact maxdepth=2 headings=bullet headstart=2
showcats=1 showarts=1>ARM</ncl>

[[Category:ARM| ]]
__NOTOC__

AVR-Studio

2012-04-21T20:03:11Z

Mthomas: /* Offizielle Seite */

Das '''AVR-Studio''' ist eine kostenlose Entwicklungsumgebung ([[Editoren/IDEs|IDE]]) für die Programmierung der [[AVR]]-[[Mikrocontroller]] von Atmel. Sie basiert ab Version 5 auf der Visual Studio Shell von Microsoft und besteht aus einer Projektverwaltung, einem [[Editoren/IDEs#Texteditoren für Programmierer|Editor]], einem [[AVR-Studio#Debugger|Debugger]] und Werkzeugen zum beschreiben der Mikrocontroller.

Mit dem AVR Studio kann in [[Assembler]] sowie in [[C]]/[[C-Plusplus|C++]] programmiert werden. Für die Unterstützung von C/C++ musste bis einschließlich Version 4 vor der Installation des AVR Studio der GNU C Compiler für AVRs [[WinAVR]] installiert werden. Ab AVR Studio 5 ist eine vollständige Toolchain zur Entwicklung von C-Projekten enthalten. Atmel bietet weiterhin eine Erweiterung zwecks Erstellung von Projekten mit eingeschränkter C++-Unterstützung an (siehe [[AVR_Studio#Tipps_.26_Tricks|Tipps & Tricks]]).

== Debugger ==
Die AVR-Studio-Umgebung sieht unabhängig von der speziellen Debug-Plattform größtenteils identisch aus. Es existieren folgende Debug-Möglichkeiten:
# [[AVR-Simulation#AVR_Studio|AVR Simulator]]
# AVR In-Circuit Emulator / [[JTAG]]-Adapter: AVR Dragon, AVR ONE!, JTAGICE3, JTAGICE mkII
'''Simulation'''
* die meisten AVR-Mikrocontroller werden unterstützt
* z.T langsamer als eine Emulation (insbesondere bei größeren Projekten)
* Wechselwirkung mit Peripherie nur über vordefinierte Stimuli möglich
* Anzeige aller Register zu jeder Zeit möglich
'''Emulation'''
* Unterstützung von Mikrocontrollern plattformabhängig eingeschränkt
* z.T. schneller als Simulation
* Debugging in tatsächlicher Hardwareumgebung
* Register nicht uneingeschränkt lesbar

== Tipps & Tricks ==

* [[AVR-Studio Bugs]]

* [[AVR-Simulation]]

* [http://www.mikrocontroller.net/topic/193587#1894280 Pfad zum Hexfile]

* [http://www.mikrocontroller.net/topic/237681#2411339 Anzeige der Größe benutzter Speicherbereiche in AVR Studio 5]

* [http://www.mikrocontroller.net/topic/236601#2413654 C++ Templates (beta) für AVR Studio 5] (Vorsicht: kein vollständiger Funktionsumfang, siehe [http://support.atmel.no/bin/customer.exe?=&action=viewKbEntry&id=1001 FAQ])

* [http://www.rn-wissen.de/index.php/AVR_Studio_5#Eigene_Templates_erzeugen Erstellung eigener Templates in AVR Studio 5]

== Downloads ==

=== Offizielle Seite ===
* http://www.atmel.com/avrstudio
* http://www.atmel.no/beta_ware/ (gelegentlich Aktualisierungen und Testversionen)

=== Direktlinks Installer ===

Anm.: Die MD5 Checksumme dient zum Überprüfen der Downloads auf Vollständigkeit. Die aktuelle Version ist '''fett''' markiert.

Im Falle nicht eingepflegter Updates hier der Direktlink-Präfix (entsprechenden Dateinamen aus dem Formularlink kopieren und hinter dem letzten Schrägstrich einfügen):

http://www.atmel.com/Images/

*[http://www.atmel.com/Images/as6installer-6.0.1703-full.exe as6installer-6.0.1703-full.exe] '''Atmel Studio 6 BETA installer (731MB, updated 2012/03)'''

*[http://www.atmel.com/Images/as6installer-6.0.1703-small.exe as6installer-6.0.1703-small.exe] '''Atmel Studio 6 BETA installer (516MB, updated 2012/03)'''

*[http://www.atmel.com/Images/as5installer-stable-5.1.208-full.exe as5installer-stable-5.1.208-full.exe] '''AVR Studio 5.1 installer (includes VSS, .NET4.0, ASF 2.11.0 and Toolchain 3.3.1) (616MB, updated 2012/02)'''

*[http://www.atmel.com/Images/as5installer-stable-5.1.208-small.exe as5installer-stable-5.1.208-small.exe] '''AVR Studio 5.1 installer (includes ASF 2.11.0 and Toolchain 3.3.1) (396 MB, updated 2012/02)'''

*[http://www.atmel.com/Images/as5installer-5.1.148.beta-full.exe as5installer-5.1.148.beta-full.exe] AVR Studio 5.1 Beta installer (includes VSS and .NET) (523 MB, updated 2011/12)

*[http://www.atmel.com/Images/as5installer-5.1.148.beta-small.exe as5installer-5.1.148.beta-small.exe] AVR Studio 5.1 Beta installer (308 MB, updated 2011/12)

*[http://www.atmel.com/Images/AvrStudio4Setup.exe AvrStudio4Setup.exe] '''AVR Studio 4.19 (build 730) (124 MB, updated 2011/09/11)''' MD5:609209DB9A1C6191945421299101DC15

*[http://www.atmel.com/Images/AvrStudio417Setup.exe AvrStudio417Setup.exe] AVR Studio 4.17 (build 666) (112 MB, updated 07/09) MD5:9705a9362da76aa9779322127640a184

*[http://www.atmel.com/Images/AvrStudio416Setup.exe AvrStudio416Setup.exe] AVR Studio 4.16 (build 628) (126 MB, updated 02/09) (last version for Win98) MD5:d1c412d7a05a9ad95486d7ea680f68e5

*[http://www.atmel.com/Images/aStudio4b589.exe aStudio4b589.exe] AVR Studio 4.14 (build 589) (89 MB, updated 04/08)

*[http://www.atmel.com/Images/aStudio4b528.exe aStudio4b528.exe] AVR Studio 4.13 (build 528) (73 MB, updated 03/07)

=== Direktlinks Zusatzsoftware ===

* [http://www.atmel.com/Images/AVRQTouchStudioSetup_VSS_dotNET.exe AVRQTouchStudioSetup_VSS_dotNET.exe] AVR QTouch Studio mit .NET (373 MB, updated 03/10)

* [http://www.atmel.com/Images/avr-toolchain-installer-3.3.0.710-win32.win32.x86.exe avr-toolchain-installer-3.3.0.710-win32.win32.x86.exe] '''AVR Toolchain 3.3.0 (94 MB, updated 2011/09/11, AVR-GCC: 4.5.1, AVR-LIBC: 1.7.1)''' MD5: 1c43bac156cb1e4cb77dfc7a833cf237

* [http://www.atmel.com/Images/avr-toolchain-installer-3.2.3.579-win32.win32.x86.exe avr-toolchain-installer-3.2.3.579-win32.win32.x86.exe] AVR Toolchain 3.2.3 (95 MB, updated 06/11, AVR-GCC: 4.5.1, AVR-LIBC: 1.7.1)

* [http://www.atmel.com/Images/avr-toolchain-installer-3.0.0.240-win32.win32.x86.exe avr-toolchain-installer-3.0.0.240-win32.win32.x86.exe] AVR Toolchain 3.0.0 (87 MB, updated 09/10, AVR-GCC: 4.4.3, AVR-LIBC: 1.7.0) MD5:999B3DC3DF471B3A667CF0FE90A522E8. Update util/delay.h [http://www.mikrocontroller.net/topic/196738#1943039] beachten.

* [http://www.atmel.com/Images/asf-standalone-archive-2.10.0.zip asf-standalone-archive-2.10.0.zip] '''AVR SoftwareFramework 2.10.0 - drivers and libraries (87 MB, revision 2.10.0, updated 2012/1/12)'''

* [http://www.atmel.com/Images/asf-standalone-archive-2.9.0.zip asf-standalone-archive-2.9.0.zip] AVR SoftwareFramework 2.9.0 - drivers and libraries (79 MB, revision 2.9.0, updated 12/11)

* [http://www.atmel.com/Images/as5.1-asf-vsix-stable-2.11.1.30-win32.win32.x86.zip as5.1-asf-vsix-stable-2.11.1.30-win32.win32.x86.zip] '''AVRStudio5-ASF-Update-2.11.1.30 (174 MB, revision 2.11.1, updated 2012/02/)'''

* [http://www.atmel.com/Images/AVRStudio5-ASF-Update-2.8.1.76.exe AVRStudio5-ASF-Update-2.8.1.76.exe] AVRStudio5-ASF-Update-2.8.1.76 (222 MB, revision 2.8.1, updated 2011/10/11)

== Weblinks ==
* [http://www.youtube.com/user/AtmelCorporation#g/c/8F325BE889E62E50 YouTube-Playlist: AVR Studio 5 Tutorial]

* [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=82994 How to install JTAGICE mkII (and AVR Dragon and AVRISP mkII) on Windows 7 x64] auf avrfreaks.net (ggf. kostenlos registrieren). Siehe auch Hinweis von Denny [http://www.mikrocontroller.net/topic/146857#1476962] im Forum.

*[http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR Eclipse Plugin]

*[http://avrstudio5.wordpress.com/ AVR Studio 5 Blog] - Useful hints and tips for installation troubleshooting with the new AVR Studio 5

[[Category:AVR]]
[[Kategorie:Entwicklungstools]]

Vorlage:Navigation zurückhochvor

2012-04-21T19:57:32Z

Mthomas: Schützte „Vorlage:Navigation zurückhochvor“ ([edit=autoconfirmed] (unbeschränkt) [move=autoconfirmed] (unbeschränkt))

<div style="text-align: center;">
[[{{{zurücklink}}}|Zurück zu {{{zurücktext}}}]] | [[{{{hochlink}}}|Hoch zu {{{hochtext}}}]] | [[{{{vorlink}}}|Vor zu {{{vortext}}}]]
</div>

Vorlage:Navigation zurückhochvor

2012-04-21T19:56:15Z

Mthomas: Änderungen von 188.165.212.59 (Diskussion) rückgängig gemacht und letzte Version von Yahp wiederhergestellt

<div style="text-align: center;">
[[{{{zurücklink}}}|Zurück zu {{{zurücktext}}}]] | [[{{{hochlink}}}|Hoch zu {{{hochtext}}}]] | [[{{{vorlink}}}|Vor zu {{{vortext}}}]]
</div>

Temperatursensor

2012-03-07T18:20:30Z

Mthomas:

Will man mit einem [[Mikrocontroller]] Temperaturen messen, dann braucht man
* einen [[Sensor]], der die Temperatur z. B. in eine Spannung oder einen Strom umsetzt
* einen [[ADC | AD-Wandler]], der das Signal digitalisiert. Der kann auf dem Sensor oder dem Mikrocontroller integriert sein.

Temperatursensoren gibt es nun in allen möglichen Varianten. Vom temperaturabhängigen [[Widerstand]] bis zum fertig abgeglichenen All-in-one-Bauteil mit digitalem Ausgang. Wie bei allen Sensoren sollte man auch hier genau hinschauen und [[Auflösung und Genauigkeit]] unterscheiden.

== Analoge Temperatursensoren ==

=== PT100 ===

Unter einem PT100 versteht man einen Platinwiderstand, der bei 0°C einen Widerstand von 100Ω hat.
Platinwiderstände sind temperaturabhängige Widerstände mit hoher Wiederholgenauigkeit und Konstanz[http://de.wikipedia.org/wiki/Konstante]. Wegen der relativ geringen Widerstandsänderung von nur ca. 0,4Ω pro Grad ist etwas mehr Schaltungsaufwand erforderlich als bei anderen Sensoren. Genauere Formeln zur Temperaturbestimmung gibt es u.a. bei der [http://de.wikipedia.org/wiki/Pt100 Wikipedia]. Ein Schaltplan findet sich bei der [http://www.heise.de/ct/artikel/Sensibelchen-289608.html c't].

Die Sensoren gibt es auch mit anderen Widerstandswerten, z. B. mit 1000Ω und heißen dann entsprechend PT1000.

Vorteil:
* genormt
* großer Meßbereich
* hohe Linearität
* hohe Wiederholgenauigkeit
* einfach austauschbar

Nachteil:
* relativ teuer (bei segor.de ab 3,80€)
* brauchen aufwendigere Auswerteschaltung

Links:
* [http://www.heise.de/ct/04/22/236/ c't-Artikel: Mikrocontroller-Programmierung: Timer, Sensoren und Drehgeber (mit PT100 Schaltung)]
* [http://pdfserv.maxim-ic.com/en/an/AN3450.pdf Maxim AN3450 Positive Analog Feedback Compensates PT100 Transducer]

=== NTC/PTC ===

NTC und PTC sind temperaturabhängige Widerstände.

* NTC (engl. '''N'''egative '''T'''emperature '''C'''oefficient, Heißleiter), hat bei hohen Temperaturen seinen niedrigsten Widerstand, z. B. Silizium
* PTC (engl. '''P'''ositive '''T'''emperature '''C'''oefficient, Kaltleiter), hat bei niedrigen Temperaturen seinen geringsten Widerstand, z. B. Glühlampe

Um den Widerstandswert zu messen schaltet man sie mit einem normalen Widerstand oder einer [[Konstantstromquelle]] in Reihe zu einem [[Spannungsteiler]] und misst den Spannungsabfall. Eine Beispielschaltung findet sich [http://www.mathar.com/msp_thermo1.html hier].

Vorteil:
* billig (z.B. [http://www.reichelt.de/?ARTICLE=9594 KTY81-110] bei Reichelt ~0,60€)

Nachteil:
* müssen für höhere Genauigkeiten abgeglichen werden
* brauchen A/D-Wandler
* sind nichtlinear

Beispiele:
* KTY10-5
* KTY13-6
* KTY81-121
* KTY81-122

Links:
* [http://www.sprut.de/electronic/temeratur/temp.htm Temperaturabhängige Stromquelle und NTC/PTC inclusive Linearisierung]
*[http://www.umnicom.de/Elektronik/Mikrokontroller/Atmel/AtFan/AtFan.html#2.2.2 Berechnung des Linearisierungswiderstandes für gewünschten Temperaturbereich] der fällt sonst immer vom Himmel
* [http://www.mikrocontroller.net/topic/208587#2065880 KTY 10-5 Formelprobleme]
* [http://www.mikrocontroller.net/topic/225563 Codesammlung: Beispiel mit 0,5°C Auflösung]

=== LMx35 ===

Eine IC-Familie, die pro Kelvin Temperaturänderung ihre Ausgangsspannung um 10 mV ändert. Die ICs gibt es in verschiedenen Genauigkeiten und Temperaturbereichen mit den Bezeichnungen LM135(A), LM235(A) und LM335(A). Der günstigste ist der LM335 mit einem Temperaturbereich von −40 … +100°C.
In verschiedenen Bauformen erhältlich. Beispielschaltungen finden sich im [http://www.national.com/ds.cgi/LM/LM135.pdf Datenblatt] und [http://www.suessbrich.info/elek/elektherm1.html hier]

Vorteile:
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)
* relativ billig (LM335 bei Reichelt ab 0,50 €)

Nachteile:
* benötigt A/D-Wandler
* bei längerer Anschlussleitung störanfällig

Links:
* [http://www.schramm-software.de/tipps/temperaturmessung/analogsensoren.htm Test-Schaltungen und -Code zur Auswertung mit ADC (AVR-Assembler)]

=== LM334 ===

Ein IC ähnlich dem LM335 mit dem Unterschied, dass der durch das IC fließende Strom proportional von der Temperatur abhängt. Mit einer einfachen Schaltung aus nur zwei Widerständen kann man dann den Strom in einer Weise wandeln, dass pro Kelvin eine Spannungsänderung von 10mV ausgegeben wird. Da die Strom-Spannungswandlung auf der Platine (und damit nahe am AD-Wandler) stattfindet und die Übertragung des Messwerts durch einen Strom stattfindet, sind Störungen durch Netzbrumm etc. viel geringer als beim LM335

Vorteile:

* relativ billig ([http://www.reichelt.de/?ARTICLE=10468 Reichelt 0,54 €])

Nachteile:
* benötigt A/D-Wandler
* Bereich 0°C-70°C

Ähnliche ICs:
* AD592 (Ausgangsstrom 1µA pro Kelvin, absolute Temperatur) [http://www.reichelt.de/?ARTICLE=3825 Reichelt: 3,75 €], Conrad 174912 8,50 €

=== SMT160-30 ===

Ist ein Zwischending zwischen Digital und Analog. Sein Ausgangssignal ist ein digitales PWM-Signal, zu dessen Messung man am besten den Input-Capture-Eingang eines Mikrocontrollers verwendet. Man kann ihn also wie einen analogen Sensor nur indirekt auslesen, anstatt über einen AD-Wandler hier über einen Timer.

Vorteile:
* Digitales PWM-Signal ist unempfindlich gegen Störeinflüsse
* gibt es in SO8, TO18, TO92 und TO220, gut befestigbar, z.B am Kühlkörper
* linear
* kein Abgleich nötig

Nachteile (viele):
* benötigt Timer
* jittert extrem, genaue Messungen nur über Mittelung / Filterung möglich
* nicht nur das PWM-Verhältnis, sondern auf die Frequenz ist temp-abhängig (1-4kHz)
* teuer (Farnell 10,90€ +16%, Conrad 9,xx€ , www.hy-line.de ??).
* TO92 Gehäuse ist günstiger, dafür weniger genau

Links:
* http://www.hy-line.de/co/sensor-tec/hersteller/smartec/smt-160-30/index.html

=== Thermoelement ===

Ein Thermoelement besteht im einfachsten Fall aus zwei ungleichen Metallendrähten, die an einem Punkt miteinander verbunden sind und bei dem die Verbindungsstelle einer anderen Temperatur ausgesetzt ist als die offenen Enden der Drähte. An den offenen Enden der Drähten entsteht eine Spannung (Thermospannung). Dieser Effekt wurde 1821 von Thomas Seebeck entdeckt ([http://de.wikipedia.org/wiki/Seebeck-Effekt Seebeck-Effekt] bei Wikipedia). Eine weitere Anwendung ist der thermoelektrische Generator ("Thermogenerator").

Vorteil:
* über einen sehr weiten Temperaturbereich einsetzbar

Nachteil:
* die sehr geringen Temperaturspannungen im Mikrovoltbereich benötigen eine sehr gute Auswertelektronik (guter Analogteil + AD-Wandler).

Links:

* [http://www.sensorwell.at/fileadmin/templates/images/data_sheets/temperatur_messtechnik.pdf Warum Thermoelemente Relativtemperaturen messen! oder Was ist eine Kaltstelle?] - Technische Information von www.sensorwell.at (PDF, ca. 600kB)

== Digitale Temperatursensoren ==

=== DS1621 ===

Der DS1621 ist Temperatursensor und A/D-Wandler in einem. Er gibt seine Daten per [[I²C]]-[[Bus]] aus. Ein Schaltplan für einen elektronischen Thermometer mit diesem IC findet sich [http://www.myplace.nu/avr/thermo/ hier].

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* da I²C ein Bus ist, kann man mehrere DS1621 und andere I²C-Bausteine zusammen anschließen und braucht dafür trotzdem nur zwei I/O-Ports.
* Messbereich -55°C to +125°C
* Genauigkeit +-0,5°C
* Auflösung besser 0,01°C, wenn man die beiden Zählerregister (Count-Remain und Count-per-C) auswertet

Nachteile:
* teuer (Segor 5,80€; RS 3,95€; Conrad 5,22€)
* obwohl die meisten Register [[Speicher#NVRAM | nichtflüchtig]] sind, kann man ihn nicht als Stand-Alone-Thermostat einsetzen, da er erst nach einem Start-Conversion-Befehl zu messen beginnt.

Nachfolger:
* DS1631, DS1631A (Auto-Start-> Stand-Alone-Thermostat), DS1731
* weitere Stand-Alone-Thermostaten: DS1821, DS1629

=== LM75 ===

Der LM75 ist so ähnlich wie der DS1621, allerdings nur in SMD erhältlich und nicht so genau. Er ist aber öfters mal auf PC-Mainboards zu finden, so dass man beim Schlachten eines solchen günstig an einen Temperatursensor kommen kann. Eine Beispiel Schaltplan mit einem ATmega8 findet man [http://www.ucblog.de/2010/09/mikrocontroller-thermometer-schaltplan/ hier]

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* I²C-Bus Ausgang
* billiger als DS1621 (Reichelt 1,45 €; RS 3V: 3,75€; 5V: 2,72€)
* Auflösung +-0,5°C

Nachteile:
* nur im SMD-Gehäuse erhältlich
* relativ ungenau (+-2°C), kann man jedoch kalibrieren / kompensieren

Kompatible Typen:
* AD7415ART
* DS7505S+

=== LM76 ===

Der LM76 ähnlich dem LM75, bietet aber eine 8-fach höhere Auflösung und eine Genauigkeit von 0.5 bzw. 1°C.

Vorteile:
* höhere Auflösung
* höhere Genauigkeit

Nachteil:
* schwerer zu beschaffen

=== TMP175 / TMP75 ===

Ähnelt dem LM75 stark! Temperatursensor von Texas Instruments.

=== DS18S20 / DS18B20 ===

Der DS18S20 (Nachfolger des DS1820) und DS18B20 sind scheinbar Temperatursensoren und A/D-Wandler in einem. Wenn man genauer hinschaut, stellt man fest, dass es sich um direktwandelnde Sensoren handelt. Die Temperatur wird ohne Umweg über eine analoge Zwischengröße (Spannung oder Strom) in ein digitales Signal überführt.

Die Datenkommunikation erfolgt über ein 1-Wire-Interface, wodurch man am [[Mikrocontroller]] mit nur einem einzigen I/O-Pin auskommen kann. Außerdem beherrschen sie die parasitäre Stromversorgung, d.h., man braucht für Daten und Stromversorgung zusammen nur zwei Leitungen.

Beim DS18B20 sind Auflösungen von 9, 10, 11 und 12 Bits konfigurierbar. Je kleiner die Auflösung, desto kürzer ist die Messzeit. Der DS18S20 hat eine feste Auflösung von 12 Bits, wobei die unteren 3 Bits aufwändiger auszuwerten sind als beim DS18B20. Der DS18S20 ist als Ersatz für den DS1820 gedacht. Der Hersteller empfiehlt den DS18B20 für Neuentwicklungen.

Vorteile:
* bereits kalibriert
* Genauigkeit +-0,5°C
* 1-Wire-Ausgang

Nachteil:
* relativ teuer: Reichelt: 2,50€ / CSD: 1,85€ / Conrad 5,08€

Links:
* [http://pdfserv.maxim-ic.com/en/ds/DS18S20.pdf Datenblatt DS18S20]
* [http://pdfserv.maxim-ic.com/en/ds/DS18B20.pdf Datenblatt DS18B20]
* [http://www.maxim-ic.com/app-notes/index.mvp/id/4377 Vergleich DS18B20 <-> DS18S20]
* [http://www.mikrocontroller.net/topic/6505 Code zur Ansteuerung (ASM ATTiny12)]
* [http://www.mikrocontroller.net/topic/14792 Code zur Ansteuerung (AVR-GCC)]
* [http://gandalf.arubi.uni-kl.de/avr_projects/tempsensor/ Code zur Ansteuerung mit CRC-Prüfung (AVR-GCC)]
* [http://www.schramm-software.de/tipps/temperaturmessung/digitalsensoren.htm Code zur Ansteuerung mit CRC-Prüfung (AVR-Assembler)]
* [http://chaokhun.kmitl.ac.th/~kswichit/avrthermo/avrthermo.html LED-Thermometer mit AT90S2313 (C)]
* [http://www.mikrocontroller.net/forum/read-4-248219.html Webserver zur Ansteuerung von bis zu 63 Bausteinen]
* [http://www.teslabs.com/openplayer/docs/docs/other/ds18b20_pre1.pdf PDF Anleitung zur Beschaltung und Programmierung (C)]
*[http://www.digitemp.com/building.shtml Anleitung Sensorfühleraufbau (DigiTemp)]
* http://www.mikrocontroller.net/topic/14792
* http://www.mikrocontroller.net/topic/232156 (Timing der parasitären Versorgung)

=== DS1822 ===

Ähnlich wie DS18S20, aber weniger genau (+-2°) und in großen Stückzahlen billiger. Wegen der geringeren Verbreitung kommt der Preisvorteil aber bei Einzelstücken nicht beim Kunden an. So kostet er bei Reichelt mit 3,50€ mehr als der DS18S20.

=== DS1921 / DS1922 ===

Sind wie die DS1821 1-wire-Sensoren mit zusätzlicher Logging-Funktion.
Im iButton-Gehäuse befindet sich eine Lithium-Zelle, eine RTC, CMOS-RAM und der Temp-Sensor. Nach umfangreicher Progammierung startet der Button seine Mission (Aufzeichnung des Temperaturverlaufs).
Gibt es auch mit zusätzlicher Feuchtemessung (DS1923).

=== TSic ===

Die TSic Sensoren werden baugleich von 3 Herstellern angeboten:
* ZMD ([http://www.zmd.biz/temp.php?group=temp&content=products Homepage]) ([http://tarr.uspto.gov/servlet/tarr?regser=serial&entry=78673282 Trademark])
* IST AG ([http://www.ist-ag.com/eh/ist-ag/de/home.nsf/contentview/8F5D32432CAC53C2C1257405003C2433 Homepage])
* Hygrosens ([http://www.hygrosens.de/english/shop/list.html?tx_ttproducts_pi1%5Bcat%5D=11&cHash=dcd89b823b Homepage])

Die TSic Sensoren ([http://www.zmd.biz/pdf/ZMD%20TSic%20Data%20Sheet%20V3%207.pdf Datenblatt]) geben ihre Temperaturmessdaten automatisch in einem festen Intervall aus. Daher muss der Host nur warten bis die nächsten Messdaten rausgeschickt werden. Die TSic Sensoren die es im freien Handel gibt, geben ihre Messdaten alle 100ms (10Hz) aus.
Zur Übertragung wird das [http://www.zmd.biz/pdf/IST_TSic_ZACwire_V2.3%20Digital%20Output_17-Oct-06.pdf ZACwire] Protokoll benutzt. Es handelt sich um eine einfach zwei Byte Übertragung per Manchester-Code. Diese zwei Byte repräsentieren den digital gewandelten Temperaturwert. Im Gegensatz zu Sensoren wie den DS18xxx von Dallas muss dieser Wert aber erst auf einen dezimalen Wert umgerechnet werden.
Die Sensoren kommen mit 3 Pins aus (VCC, GND, Dout).

Vorteile:
* Bereits kalibriert
* Verschiedene Genauigkeiten lieferbar
* Sehr einfaches Kommunikationsprotokoll
* Geringer Stromverbrauch
* Hochgenau: bis zu +/- 0.1°C (TSic 50x)

Nachteil:
* Recht teuer (Reichelt: 4,70€ für den TSic206)
* Nur ein Sensor an einem I/O nutzbar (Kein Bussystem)

Achtung!
Die TSic Sensoren gibt es auch als Version mit analog Ausgang. Bei der Typenbezeichnung gibt die 3. Stelle an ob es sich um die analog- oder Digitalversion handelt (1 = analog, 6 = digital).
Der TSic201 ist also analog, wärend der TSic206 ein digitaler ist.

Links:
* [http://www.avr-projekte.de/zacwireasm.htm Zacwire Protokoll, AVR-Assembler]
* [http://www.mikrocontroller.net/topic/45573#347765 Ansatz zum Empfang der Daten]
* [http://www.mikrocontroller.net/topic/225554# Beispiel mit Strobe ohne Interrupt]
* [http://ethersex.de/index.php/Zacwire Fertige Ansteuerung durch AVR in Ethersex]
* [http://www.zmd.biz/temp.php?group=temp&content=products Herstellerseite mit Datenblättern und FAQ]
* [http://www.mikrocontroller.net/topic/82087 Diskussion mit Beispielcode (MSP430, AVR, PIC) blockierend]
* [http://www.mikrocontroller.net/topic/144424#1367539 C++ Interrupt]
* [http://www.mikrocontroller.net/topic/88847 noch mehr C, problematisch Interrupt]
* [http://www.mikrocontroller.net/topic/151791#1426974 C für ATmega8]
* [http://www.mikrocontroller.net/topic/159149#1510455 auch problematisch]
* [http://www.sinc.sunysb.edu/Stu/maman/ESE_381.htm Projekt mit tsic sensor, evtl. code]
* [http://www.mikrocontroller.net/topic/188462#1837622 fertiger Code zum Einlesen des Zacwire-Protokolls für PIC in ASM]
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=55103 RN: Bascom]
* [http://www.mikrocontroller.net/search?query=tsic* Suche in den Foren]
* [http://www.avr-projekte.de/tinyclock.htm TSIC206 Thermometer mit Uhr und Kalender. Komplette Bauanleitung mit ASM Quellcode für AT-Tiny2313]

=== SHT1x/SHT7x ===

Der SHT1x/SHT7x (SHT10, SHT11, SHT15, STH71, SHT75) sind kombinierte Temperatur- und Feuchtesensoren von [http://www.sensirion.com Sensirion]. Sie unterscheiden sich in Bauform und Genauigkeit.

Vorteile:
* digitale Schnittstelle mit einfacher [[I²C]]-''ähnlicher'' Ansteuerung
* keine Kalibrierung notwendig
* Beispielcode (C, MC51) auf der Sensirion-Seite verfügbar (relativ leicht portierbar)
* interne Heizelemente (Funktionsprüfung, "rauhe" Umgebung)
* Spannungsmonitor ("Battery fail")
* sehr hohe Genauigkeit

Nachteile:
* kann nicht am [[I²C]] Bus betrieben werden, theoretisch gleiche Clockleitung möglich, fixe Adresse
* relativ teuer (Farnell 18,60€)(SHT11 bei CSD 14€)

[http://www.sensirion.com/en/01_humidity_sensors/00_humidity_sensors.htm Übersicht] der Temperatur- /Feutchtigkeitssensoren von Sensirion.

=== SHT21 ===

[http://www.sensirion.com Sensirion] bietet auch den SHT21 Feuchtigkeits- und Temperatursensor an, welcher wesentlich genauer ist.

Vorteile:
* I2C digital, PWM and SDM/analog Volt Ausgabe
* Maximal 5 Messungen/s @ 14bit
* Temperaturbereich von -40 – +125°C
* Feuchtigkeit mit einer Genauigkeit von +-3%RH

Nachteile:
* teuer (Farnell 23 €, Segor 29 €)
* nur als SMD-Package

Application Notes und Datenblätter findet man [http://www.sensirion.com/en/01_humidity_sensors/10_Overview.htm hier].

=== ADT7310 ===

Der [http://www.analog.com/en/sensors/digital-temperature-sensors/adt7310/products/product.html ADT7310] von [http://www.analog.com/ Analog Devices] besitzt eine Auflösung von 16 Bit und eine Genauigkeit von ±0.5°C im Bereich von −40°C bis +105°C.

Vorteile:
* Ansteuerung per [[SPI]] (für [[I2C]] siehe [http://www.analog.com/en/sensors/digital-temperature-sensors/adt7410/products/product.html ADT7410])
* keine Kalibrierung notwendig
* hohe [[Auflösung und Genauigkeit]]
* programmierbarer [[Interrupt]]ausgang für Unter- und Übertemperatur
* relativ günstig (ca. 3€ bei Digi-Key, Stand 12/2011)

Nachteile:
* TBD

[[Category:Sensorik]]
[[Category:Bauteile]]

Elektronikversender

2012-02-09T23:19:12Z

Mthomas: /* Glyn (GLYNshop) */

== Einleitung ==

Die Vor- und Nachteile von verschiedenen Elektronik-Versand-Händlern werden relativ häufig im Forum diskutiert. Diese Diskussionen führen nicht selten zu weitestgehend gleichen Ergebnissen. In diesem Artikel sollen daher die Argumente, die für oder gegen einen bestimmten Elektronik-Versender sprechen, zusammengetragen werden. Sobald diese Liste einigermaßen vollständig ist, würde dies sicher einige Diskussions-Threads und/oder Flame-Wars überflüssig machen.

Diese Liste erhebt keinerlei Anspruch auf Vollständigkeit, d.h. wenn ihr einen Versender kennt, der hier noch nicht aufgeführt ist, dann nennt wenigstens die URL und den Namen. Den Rest können auch andere besorgen, die den Versender ebenfalls kennen!

Bitte ergänzt nur allgemeine Sachen (z. B. "liefert immer vollständig", "günstig" oder "große Auswahl"), aber nicht Sachen wie "mein ATMega 128 hatte verbogene Beine"! Bitte auch die alphabetische Sortierung beibehalten!

'''Diese Seite kann nur von angemeldeten Benutzern bearbeitet werden!'''

== Liste der Versender ==

=== AATiS ===
Homepage: http://www.aatis.de

* Arbeitskreis Amateurfunk und Technik in der Schule e.V.
* Bausätze speziell auch für Elektronik-Anfänger, Schüler
* Literatur, Seminare für Lehrer

=== Actron ===
Homepage: http://www.actron.de

* '''kein''' Online-Shop!
* alphanumerische LCDs und Graphikdisplays in großer Auswahl, auch mit Touchscreens
* für gewerbliche Kunden: etwas verhandeln schadet nie
* bei kleinen Stückzahlen nicht ganz billig
* liefern sehr schnell und stets zuverlässig

=== Adapterprofi ===
Homepage: http://www.adapterprofi.de

* Bauteile, Gehäuse, Netzteile
* Viele unterschiedliche HF-Adapter
* Seite aktuell nicht erreichbar (10.12.2011)

=== AK Modul Bus Computer GmbH ===
Homepage: http://www.ak-modul-bus.com/stat/produkte.html

* Interfaces, Messmodule, Funktionsmodelle, Experimentiersysteme
* Entwicklungssysteme, Baugruppen, Elektor, Zubehör, Bauelemente
* Software, Lernpakete, Bücher, Sonderposten

=== Allpax ===
Homepage: http://www.allpax.de

* Liefert auch an Privathaushalte
* Keine Elektronik an sich, aber ggf. nützliches Zubehör: Größeres, übersichtliches Sortiment an ESD-Beuteln und -Folien, offen und mit Zippverschluss, Pink Poly und Metallisiert (High Shield). Preislich über Farnell, dafür findet man sofort, was man sucht...
* außerdem Ultraschallreiniger, Waagen und Folienschweißgeräte, sowie viel Fachfremdes
* Versandkosten: 8,33€ nach Deutschland, diverse EU-Länder 17,85€, Schweiz 34,51€; Versandkostenfrei in D ab 178,50€
* Gewährt scheinbar auch Privatkunden die Zahlung per Rechnung; bei Bankeinzug 2% Rabatt, bei Vorkasse und Abholung 3%

=== AME-Engineering ===
Homepage: http://www.ame-engineering.de

* Hochfrequenz-Spezialitäten, Amateurfunk

=== Amidon ===
Homepage: http://www.amidon.de

* Sehr großes Sortiment, vorallem für seltene Bauteile, z. B. Dioden

=== Andy's Funkladen ===
Homepage: http://www.andyfunk.de

* Alles für Amateur- und CB-Funk
* Bauteile und Gehäuse

=== Anvilex ===
Homepage: http://shop.anvilex.com/index.html

* Liefert sehr günstige Break-Out Boards für diverse Packages
* Hat einige einfache und günstige Programmer auch für FPGAs etc

=== Atlantis Shop 24 ===
Homepage: http://www.atlantis-shop24.de

* Elektronik nur ein kleiner Teil des Angebotes. Ansonsten eher Drogerie bzw. Haushaltsbedarf

=== Atzert-Elektronik Versand ===
Homepage: http://www.atzert-elektronik.de

Früher ''EFB-Electronic Versand'', davor ''MEGAKICK Electronic Stores''.

* Mindestens schon der dritte Name und die dritte Webseite für den Endkunden-Versand von [[Elektronikversender#ETT|ETT]]. ETT liefert sonst nur an gewerbliche Kunden.
* Ladengeschäfte in Bielefeld, Braunschweig, Bremen, Hamburg und Berlin.
* Die Preise schwanken im Vergleich zu anderen Anbietern, welche ebenfalls ETT-importierte Produkte führen, mal nach oben, mal nach unten.

=== Bassenberg Elektronik ===
Homepage: http://www.bassenberg.de

* Ladengeschäfte in Braunschweig und Neumünster
* Beschafft auch nicht mehr gelistete und abgekündigte Bauteile
* Liefert auch an Privat

=== Batronix ===
Homepage: http://www.batronix.com
* Grosses Sortiment an Geräten
* Bausätze für Microcontroller-Applikationen
* Liefert auch an Privat

=== BAZ Spezialantennen ===
Homepage: http://www.spezialantennen.de

* Antennen für Amateurfunk, ISM, WLAN usw.

=== Bfi-Optilas ===
Homepage: http://www.bfioptilas.de

* Kein Onlineshop
* spezialisierter Distributor für Hochfrequenzhalbleiter und Optik

=== BG-Electronics.de ===
Homepage: http://www.bg-electronics.de

* Online Shop für aktive und passive elektronische Bauelememte
* günstige Preise
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, CarHiFi und TV-Bereich

=== B & M electronics ===
Homepage: http://www.bmelectronics.de

* Bauteile, Platinen und Baugruppen für Amateurfunk

=== Box73 ===
Homepage: http://www.box73.de

Onlineshop des Funkamateur.

* Bauteile, Bausätze, Literatur aus dem Amateurfunkbereich
* Preise sind O.K.
* Bestellungen werden nur Di und Do bearbeitet
* Ab 50 EUR bei Bankeinzug portofrei.

=== Bürklin OHG ===
Homepage: http://www.buerklin.com

* große Auswahl, hohe Verfügbarkeit
* sehr schneller Versand
* Ladengeschäft in München
* <s>nur an gewerbliche Abnehmer (lt. AGB), private Abnehmer können dennoch im Ladengeschäft einkaufen Angeblich versendet Bürklin seit November 2010 auch an Privatpersonen. Allerdings verlangt Bürklin weiterhin in Adressformularen die Eingabe eines Firmennamens Geben Sie einen Wert in das Feld "Firma" ein. Daher ist diese Information eher mit Vorsicht zu genießen.</s> Mittlerweile muss man auch keinen Firmennamen mehr eingeben. Die AGB wurde ebenfalls angepasst.
* 35 EUR Mindestbestellwert, darunter 7 EUR Bearbeitungskosten (incl. MWSt)

=== CBsoft, s.r.o. (ltd.) ===
*Homepage: http://www.jjtubes.eu/
* Firma in der Slowakei
* Verkauft Röhren der Firma JJ
* englischsprachig
* Zahlungsmöglichkeiten in € mit Paypal und Kreditkarte

=== chiptrade.com ===
Homepage: http://www.chiptrade.com
* kein Onlineshop!
* Produkte von: Trinamic Motion Control, Datasphere/BlueSerial, connectBlue, Tectus RFID, Korenix, CentiPad, eye2m und Televideo

=== ConeleK Electronic ===
Homepage: http://www.conelek.com

* Sehr kleines Bauteileangebot (Röhren, Röhrensockel)
* Elektronik-Laborbedarf, insbesondere Nachfüllpackungen mit Steckbrett-Drahtbrücken
* Werkzeug für Elektronik
* Stromversorgungen
* Versand an Privat
* Versandkosten bis 25kg, Vorkasse 5,90€ (Stand 04/2008)

=== Conrad ===
Homepage: http://www.conrad.de und http://www.business.conrad.de

* großes Angebot (für Bauteile den "Business"-Katalog beachten, der Hauptkatalog ist dahingehend etwas "dünn") (Anm.: Bauteile, die nur im Business-Katalog aufgeführt sind, sind in Ladengeschäften nur über Sonderbestellung zu bekommen, d.h. dort in aller Regel nicht vorrätig.)
* Positiv: Wirklich jedes Bauteil kann einzeln gekauft werden und wird nicht in dämlichen Verpackungseinheiten verkauft, so wie es bei den meisten anderen Elektronik-Lieferanten der Fall ist. Dies ist vor Allem für den Prototypenbau sehr hilfreich.
* relativ teuer jedoch bis zu 10% Rabatt für Schulen (bei genügend Umsatz)
* 21 Ladengeschäfte in Deutschland, fünf in Österreich
* positiv: Bei Business-Kunden wird der Rechnungsbetrag erst nach 14 Tagen abgebucht.
* haben einen (teuren) 24 Std. Lieferservice für Notfälle - Conrad garantiert aber nicht 100%ig für die Einhaltung der 24 Stunden. Bei Nichteinhaltung gibt es kein Geld zurück.
* Verfügbarkeit in Filialen kann Online überprüft werden.
* Verfügbarkeit in Filialen kann über zentale Rufnummer erfragt werden. Abholung bestellter Ware in Filialen möglich, aber trotzdem gleiche Versandkosten.


=== csd-electronics ===
Homepage: [http://www.csd-electronics.de csd-electronics.de]

* ATMEL, ICs, Passive und Mechanische Bauteile, Platinen- und Lötzubehör, u.a.
* günstig
* Mengenrabatte für fast jedes Produkt
* Versand innerhalb Deutschlands pauschal 3,59€ (ab 100 EUR versandkostenfrei)
* Versand EU-weit ab 6,95 EUR
* kein Mindestbestellwert
* schnelle Lieferung, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage beschafft werden.
* Zahlung bei Vorkasse(2% Skonto), Bankabbuchung, Kreditkarte, PayPal
* Ist man bereits Kunde, kann man "auf Rechnung" (Zahlung innerhalb von 21 Tagen) bestellen.
* haben ein Forum, in dem man sich zu Sammelbestellungen organisieren kann und auch allgemeine Fragen stellen kann -zur Zeit (05/2008) offline-

=== dad24 ===
Homepage, Shop: http://dad24.eu
E-Bay Shop: http://stores.ebay.de/Shop-dad24

* Unterschiedliche Preise in den beiden Shops
* Kleiner, nicht sonderlich schöner Onlineshop (dad24.eu)
* Kleines Angebot. Lupenleuchten, Lötstationen, Labornetzgeräte, Messgeräte, etc. aus dem unteren Preissegment
* Jede Woche eine neue "Kategorie der Woche" auf dad24.eu. Produkte aus der Kategorie werden erst im Warenkorb mit einem Rabatt angezeigt, der auch gewährt wird.

=== Darisus ===
Homepage: http://www.darisus.de

* kompetente Beratung
* liefert sehr zuverlässig, in Notfällen auch Express
* Versand innerhalb Deutschlands ab 4,50 EUR
* Hat auch eine gute Auswahl an CPLDs und einige FPGAs diverser Hersteller

=== Daschke LTD ===
PDF-Katalog (Achtung, grosse Datei): http://www.daschke-ltd.de/Catalog/

* Prompte Antwort und Hilfe via info ät obige adresse
* Bezahlung per Paypal und Rechnung möglich. Ist auch Ebay-Händler.
* sehr faire Preise für Bauteile und Versand
* Führt eine Vielzahl an unüblichen Steckern und Buchsen
* Nicht verfügbare Bauteile wurden proaktiv nachbestellt, trotz geringer Bestellmenge. Prima!

=== DES - Der Elektroniker-Shop ===
Homepage: http://www.DerElektronikerShop.de

* Bauteile
* Bauteilsätze der [http://www.DieElektronikerseite.de Elektronikerseite]
* Verkauf des BasicBeetle und Zubehör von [http://www.DieProjektseite.de der Projektseite]
* Ständig wachsendes Angebot
* Auch einige SMD-Bauteile verfügbar
* Kein Mindestbestellwert
* Versandkosten ab 3,50 EUR (Österreich/Europa ab 4,00 Eur)
* Versand auch nach Österreich (Europa auf Anfrage)
* Zahlung per Vorkasse
* Lieferzeit 1-3 Tage bei Verfügbarkeit
* PrePaid-Konto möglich
* Lieferungen auch an Privat

=== Digi-Key ===
(tlw.) deutsche Homepage: http://de.digikey.com

* optisch nicht besonders ansprechende, aber durchaus sehr funktionelle Website
* beheimatet in den USA, ein Logistikbüro gibt es in den Niederlanden
* kostenloser Versand ab 65€, darunter 18€ Versandkosten
* macht merkwürdige Plausibilitäts-Checks: wenn man privat über ihrem Dollar Limit (z.B. 400 Dollar bestellt) kommt sofort die Rückfrage nach Firmenname und Firmenadresse
* Rückfragen nach dem Verwendungszweck kommen ebenfalls schon bei der Bestellung bei bestimmten Bauteilen die der Exportkontrolle unterliegen
* Versand direkt aus den USA, dafür sehr flott mit UPS Express (in rund zwei bis drei Tagen da)
* riesiges Angebot, gewissermaßen ein Distributor der auch Kleinmengen an Privatpersonen liefert, entscheidend ist, dass der Hersteller des Produkts geführt wird
* kein anderer Anbieter, bietet so viele verschiedene passive Bauteile in kleinen Stückzahlen, z. B. SMD Widerstände in Bauform 01005 bis 2512 meist in verschiedenen Toleranzklassen und von verschiedenen Herstellern
* alle Bauteile mit Herstellerangabe, Digikey kauft ausschließlich direkt vom Hersteller
* Preise sind auf der deutschen Website in Euro inklusive etwaigem Zoll angegeben, allerdings ohne Mehrwertsteuer, die korrekt abgerechnet wird (d.h. man zahlt bei Versand nach Österreich 20% Mwst., nach Deutschland m.W.n. 19%)
* Meistens deutlich teurer als Reichelt, doch häufig die beste Anlaufstelle für Privatkunden wenn es um Spezialbauteile geht, und der Hersteller sich im Programm von Digikey befindet

* Zu beachten ist auch noch folgendes, um unliebsame zusatzkosten zu vermeiden: http://www.mikrocontroller.net/topic/90943#new. ''Anmerkung dazu: Digikey hat wohl zum 1.4.2011 den Versand umgestellt und importiert nun selbst. Zusatzkosten durch Verzollung sollten dann nicht mehr anfallen.''

=== Display Electronics ===

Homepage: http://www.distel.co.uk

* In England
* Webseite = Augenkrebs
* Online-Shop versteckt hinter dem Search-Button auf der Homepage
* Restposten aller Art
* Mindestbestellwert 10 GBP

=== eHaJo ===
Homepage: http://www.eHaJo.de

* Bausätze
* Lötübungen
* AVR-ISP-Stick

=== Eisch-Kafka-Electronic ===
Homepage: http://www.eisch-electronic.de

* Hochfrequenz Bausätze und Bauteile für Amateurfunk

=== EleConT ===
Homepage: http://www.elecont.de/shop/

* Carrierboards für gebräuchliche AVR

=== Electropuces ===
Homepage: http://perso.wanadoo.fr/electropuces/

* Gebrauchte Messgeräte aus Nantes, Frankreich (teilweise engl. Menü)

=== Electronic Search ===

Homepage: http://www.electronic-search.de

* Keine Mindestbestellmenge
* Verkauf auch an Privat/Bastler
* Fast alle Preise im Online-Shop nur "auf Anfrage", und nicht im Shop angegeben.

=== electronicpool Rheinstetten ===
Homepage: http://www.electronicpool.de

* abgekündigte oder schwer beschaffbare elektronische Bauteile

=== Elektronikladen ===
Homepage: http://www.elektronikladen.de

* Spezialist für Mikrokontroller
* Entwicklungssysteme, keine Einzelbauteile
* entsprechende Literatur und Software
* "Kein Verkauf an Endverbraucher i.S.d. §13 BGB"

=== Elektronik-Kompendium ===
Homepage: http://www.elektronik-kompendium.de

* Bausätze diverser Schaltungen (mit Anleitung und Funktionsbeschreibung)
* erspart lästiges Suchen in anderen Shops
* kurze Lieferzeiten
* günstiger Versand

=== Elk Tronic ===
Homepage: http://www.elk-tronic.de

* kleines Lieferprogramm Adapterplatinen (SMD -> 2,54mm-Raster) und Programmieradapter
* günstige Preise und Versandspesen

=== Elko-Verkauf ===
Homepage: http://www.elko-verkauf.de

* Nur Low-ESR-Elkos
* Elko-Sets für ein Gerät

=== Ellmitron ===
Homepage: http://www.ellmitron.de/
Katalog: http://www.ellmitron.de/katalog.pdf

Lehrmittel, Kleinbausätze vor allem für Schüler, Experimentierkästen

=== Elpro Darmstadt ===
Homepage: http://www.elpro.org

* Kein Mindestbestellwert, aber hohe Versandkosten für kleine Bestellungen. Stand September 2008:
** Bis 15€: 9,95€ Versandkosten
** Von €15 bis €75: 5,95€ Versandkosten
** Von €75 bis €200: 4,49€ Versandkosten
** Ab €200: Versandkostenfrei
* Große Auswahl an Mikrocontrollern
* Sehr große Auswahl an Schaltnetzteilen von Meanwell (geschlossen, offen, auf PCB lötbar, DIN-Schiene)
* Merkwürdig zu bedienende Shopsoftware, ständig klappt was auf und zu und wird irgendwas nachgeladen. Braucht JavaScript
* Keine AGBs online. Da Preisangaben ohne MwSt. richtet sich das Angebot vermutlich nicht an Endverbraucher (werden aber beliefert)
* Bearbeitungszeit (bis Warenausgang) 2-3 Tage.
* Versand bisher mit DHL
* gute bis sehr gute Verpackung

=== Eltrix ===
Homepage: http://eltrix.de/Starteltrix.htm

* Verbrauchsmaterial, Tipps und Tricks fürs Leiterplattenherstellen und Löten

=== ELV ===
Homepage: http://www.elv.de

* nicht sehr große Auswahl an Einzelteilen
* riesiges Angebot an Zubehör für Hobbyisten
* viele z.T. pfiffige Eigenentwicklungen, Bausätze (auch zum Download auf der Website verfügbar)
* sonst Sortiment ähnlich Conrad, nicht billig
* im Allgemeinen nicht billig, merkwürdigerweise sind manche Artikel aber die günstigsten auf dem Markt
* mühsamer Onlinekatalog
* Immer mal wieder Fehllieferungen und Wartezeiten (zumindest in die Schweiz). Service erreichte in 3 Fällen nicht das inserierte Niveau.
* Versandkosten innerhalb Deutschland 4,5€, ab 150€ Bestellwert versandkostenfrei
* nicht abwählbare Versandversicherung, die 0,85% des Bestellwertes kostet



=== ETT - Electronic Toys Trading ===
Homepage: http://www.ett-online.de

* Großhandel nur für Gewerbekunden.
* Zweitshop [[Elektronikversender#Atzert-Elektronik_Versand|Atzert-Elektronik Versand]] (früher EFB-Electronic Versand, davor Megakick Electronic-Stores) für Endkunden.
* Ladengeschäft in Braunschweig für jedermann. Weitere Atzert Ladengeschäfte in Bielefeld, Bremen, Hamburg und Berlin.
* Eigentümer der Marken McCHECK®, McPower®, McVoice® und anderer, unter denen ETT importierte Messgeräte, Labornetzteile, usw. an Großkunden und Händler vertreibt. Diese sind unter oben genannten Marken dann in vielen Shops anderer Firmen für Endkunden zu finden, nicht nur bei Atzert. Preisvergleiche lohnen.

=== Ettinger GmbH ===
Homepage: http://www.ettinger.de

* Für gewerbliche Kunden
* Mechanische Komponenten (Gehäuse, Abstandshalter, Drehknöpfe, usw.)
* LEDs
* Gewöhnungsbedürftiger Online-Shop

=== EVE ===
Homepage: http://www.eve.de

* Zitat aus den AGBs:
::''"Zu Bestellungen im Rahmen des Online-Handels sind nur durch uns autorisierte, d. h. zugelassene Käufer berechtigt. Wir gewähren nach erfolgreicher Zertifizierung – ohne hierzu verpflichtet zu sein – dem jeweiligen Käufer das nicht übertragbare, nicht exklusive Recht im Rahmen des Online-Handels Bestellungen uns gegenüber “auszubringen”."''

:Dies darf man wohl getrost als Hinweis ansehen, dass Endverbraucher als Kunden nicht gewünscht sind.
* Versandhaus für elektronische Artikel in Emsdetten
* machen auch Kabelkonfektion
* Pb-freie Artikel markiert

=== Farnell ===
Homepage: http://de.farnell.com

* liefert nur an gewerbliche Abnehmer, Ausnahme sind Studenten und HTL-Schüler (Österreich, Farnell.at). Nachweis wird verlangt (Gewerbeschein oder Immatrikulation).
* Lieferungen an Privat:
:* Schweiz: Farnell Schweiz beliefert auch Privatkunden.
:* Deutschland: Über den Reseller [[#HBE_-_Heinz_B.C3.BCchner_Elektronik.2C_Messtechnik.2C_med._Elektronik_e.K.|HBE]] kann man Produkte aus dem Farnell-Sortiment zu bestellen.
:* Österreich: [[#Technik-Welt / Industrieshop.at|Technik-Welt / Industrieshop.at]]
* große Auswahl
* 12% Rabatt für Studenten und Lehreinrichtungen
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (UPS), fehlende Positionen werden relativ rasch versandkostenfrei nachgeliefert
* Versandkosten: Bestellung bis 49,99€: 7,95€; 50,- bis 149,99€: 5,95€; ab EUR 150,- versandkostenfrei
* hat nach eigenen Aussagen umfangreichstes Sortiment an RoHS-konformen Bauteilen mit Suchfunktion im WWW
* leistungsfähige parametrische Suchfunktion / teils aber völlig nutzlos, da den Artikeln massenweise Tags fehlen, weswegen die Suchergebnisse unnötig eingeschränkt werden
* Datenblätter für die meisten Bauteile online
* Internetpräsenz fällt nachts oft aus (Hinweis auf angebliche geplante Wartungsarbeiten)
* Sortierfunktion wird bei der Suche ständig zurückgesetzt, im Warenkorb ist überhaupt keine sinnvolle Sortierung möglich
* Eigenwillige Preispolitik: Einiges sehr günstig, Anderes total überteuert

=== Fibra-Brandt Zweibrücken ===
Homepage: http://www.fibra-brandt.com

* lagert tausende veraltete und schwer zu findende elektronische Bauteile
* Halbleiter, IC's, Transistoren, Spulen und Kondensatoren.
* Sonderbeschaffung von abgekündigten Halbleitern.

=== Fischer DK2FD ===
Homepage: http://www.dfe-online.de

* Baugruppen für Hochfrequenzmesstechnik und Amateurfunk

=== Funkamateur Online-Shop ===

Siehe [[Elektronikversender#Box73]]

=== Futurelec ===
Homepage: http://www.futurlec.com

* günstiger Versender aus Übersee
* viele Stamp-Boards
* LED Matrix-Module

=== Geist Electronic-Versand GmbH ===
Homepage: http://www.geist-electronic.de

* Liefern Bauteile für Elektor-Projekte
* D-78054 Villingen-Schwenningen
* Versandkosten: 5.40€

=== Giga-Tech ===
Homepage: http://www.giga-tech.de

* Spezialitäten für Hochfrequenz / Amateurfunk
* 68542 Heddesheim

=== Grummes Elektronik ===
Homepage: http://www.grummes.de

* Elektronikversender /CNC-Fräsmaschinen / Schrittmotorsteuerungen / Bauteile
* Homepage nicht aufrufbar (10.12.2011)

=== Glyn (GLYNshop) ===
Homepage: https://www.glynshop.com/erp/welcome.do

* "B2B Shop" = nicht für Privatkunden
* Microcontroller, Evaluation Boards, TFT-Displays, LC-Displays, Memory Cards u.a.

=== H-Tronic ===
Homepage: http://www.h-tronic.eu/index.php

* Online-Shop einer Entwicklungsfirma, in dem neben Baugruppen und Geräten auch einige Bauelemente und Elektronikzubehör angeboten werden
* kleines Angebot

=== Hallmanns Elektronik ===
Homepage: http://www.hallmanns.com 
Adresse: Bruno Hallmanns, Weierstraße 41, 52349 Düren

* Elektronikhändler mit Ladenlokal und Versand
* Ladentypisches Sortiment (Bauteile, Geräte, PC, Funk, Hifi...)

=== Hari Seligenstadt ===
Homepage: http://www.hari-ham.com

* Bausätze, Ringkerne, Geräte für Amateurfunk

=== HBE - Heinz Büchner Elektronik, Messtechnik, med. Elektronik e.K. ===
Homepage: http://www.hbe-shop.de/katalog/

* Bezeichnet sich als ''[[#Farnell|Farnell]] Fachhändler'', bei dem nichtgewerbliche Kunden aus dem Farnell-Sortiment bestellen können.
* Preise für Farnell-Produkte normalerweise Farnell Netto-Preis + MwSt.
* Mindestbestellwert 25,- € (netto), Mindermengenzuschlag 5,- € (Stand 06/2010)
* Versandkosten 4,75 € (netto), ab 75,- € (netto) versandkostenfrei (Stand 06/2010)

=== Heho-Elektronik ===
Homepage: http://www.heho-elektronik.de
* Halbleiter / Bauteile, Sortimente, Handy - Akkus, VELLEMAN - Bausätze
* Aktuelles Angebot, Ladegeräte / Akkuladegeräte, Blei - Akkus
* Spannungswandler, Audio / Video / USB - Kabel, Netzwerk - Kabel
* 1-2 Arbeitstage für Waren ab Lager
* Porto + Verpackung pauschal Euro 4,50
* Mindestbestellwert von € 10,00

=== Hinkel ===
Homepage: http://www.hinkel-elektronik.de

* Von der Webseite "Unser Angebot richtet sich an Schulen, Behörden, Handel, Handwerk und Industrie."
* Batterien
* Knopfzellen, spezielle KZH, die man sonst lang sucht, findet man hier
* Mindestbestellwert von 20€
* Standardversand innerhalb Deutschlands 5,80€

=== HN Electronic Components GmbH & Co. KG / Netzteilshop ===
Homepage gewerbliche Kunden: http://www.hn-electronic.de/homed/framed.html 
Homepage Endkunden: http://www.netzteilshop.com/hnshop.html

* Netzteile aller Art
* Lieferung an Endkunden nur per UPS Nachnahme.
* Mindestbestellmenge für Endkunden 25 €

=== HW-Electronics ===
Homepage: http://www.hw-electronics.de 
Homepage EU: http://hw-electronics.eu/

* Tauch- und Sprühätzanlagen
* Entwicklungsgeräte
* Belichtungsgeräte, Materialsätze zum Selbstbau von Belichtungsgeräten

=== ID-Elektronik ===
Homepage: http://www.id-elektronik.de

* Amateurfunk-Baugruppen

=== IT-WNS ===
Homepage: http://www.it-wns.de

* "Bauteile, Platinen, Bausätze" insbesondere mit ATMEGA und ENC28J60
* Bausätze zu Projekten aus dem Forum, z. B. USBprog, ChipBasic, Mikro-Webserver, Transistortester u.v.a.m.
* Atmega32/644 Experimentiersystem als Bausatz mit vielen Zusatzmodul-Bausätzen
* SD-Slots, RFID, Bluetooth-Module, AVR Mikrocontroller uvam.
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage (Kontaktformular) beschafft werden
* günstige Preise und Versandkosten ab 1,90EUR, kein Mindestbestellwert
* schneller Versand, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung

=== Kabelscheune ===
Homepage: http://www.kabelscheune.de

* "Direktversand von Elektromaterial und Multimediaprodukten"

=== Kelemen ===
Homepage: http://www.kelemenantennen.de/Kelemen-Shop/

* Messgeräte, Antennen und Zubehör für den Amateurfunk

=== Kessler ===
Homepage: http://www.kessler-elektronik.de

* im Preis-Leistungsverhältnis mit Reichelt zu vergleichen (sprich: günstig)
* Sortiment kleiner als Reichelt und mit gewissen Abweichungen (z. B. andere FPGA und RAMs)
* oft lange Lieferzeiten
* Versandkosten innerhalb Deutschlands 4,95€ bei Bankeinzug und 6,90€ bei Nachnahme plus Nachnahmegebühren
* Der Download-Katalog ist von 2002! Online aktueller

=== Klein-Electronic ===
Homepage: http://www.klein-electronic.de

* Baugruppen zur Video- und 2,4GHz-Sendetechnik

=== Konni-Antennen ===
Homepage: http://www.konni-antennen.de

* Antennen für TV, Amateurfunk
* Zubehör, Einzelteile

=== Köditz Nachrichtentechnik ===
Homepage: http://www.koeditz-nachrichtentechnik.de

* Baugruppen und Bauteile für Amateurfunk und TV-Satellitenempfang

=== Kuhne DB6NT ===
Homepage: http://www.kuhne-electronic.de

* Baugruppen und Bausätze für Mikrowellenamateure

=== LEDSEE Electronics ===
Homepage: http://www.ledsee.com

* LEDs, LCDs, diverses
* Lieferung direkt aus China, daher sehr günstig und lange Lieferzeiten

=== LED Microtechnics LTD ===
Homepage: http://www.ledmeile.de

* "LED Shop und Lampentechnik"

=== LED-Tech LED-Shop ===
Homepage: http://www.led-tech.de

* viele verschiedene LEDs zu sehr guten (meist den günstigsten) Preisen
* vor allem auf High-Power-LEDs spezialisiert
* viele verschiedene Treiber für High-Power-LEDs
* kostenloser Versand
* haben ein eigenes, sehr umfangreiches Forum

=== Lieske Elektronik ===
Homepage: http://www.lieske-elektronik.de

* liefert nur an Geschäftskunden

=== LUMITRONIX LEDs-Shop ===
Homepage: http://www.leds.de

* alles rund um LEDs (auch Zubehör und Lektüre)
* neben Standard-LEDs auch SMD- und SuperFlux-LEDs

=== Marsch Elektronik, M. Schlimper ===
Homepage: http://www.marsch-elektronik.de

* Online Shop für aktive und passive Bauelemente
* Versandkosten ab Euro 1,60
* kein Mindestbestellwert
* liefert nur innerhalb Deutschlands
* nicht gelistete Artikel können angefragt werden und werden meist auch beschafft

=== Mein-Daarle ===
Homepage: http://www.mein-st-arnual.de/shop/saarbruecken/artikellisteL.html

* Teileliste eines "Händlers aus Saarbrücken" (wahrscheinl.: Frank Skowronek ESS Elektronik Service), "bis sein Onlineshop ans Netz gehen kann"
* derzeit (4/2011) kein Onlineshop, Kontakt über Formular

=== Micromaus ===
Homepage: http://www.micromaus.de

* Sensoren
* Mikrokontroller
* kein Mindestbestellwert

=== Microcontroller-Starterkits ===
Homepage: http://www.microcontroller-starterkits.de

* Bauteile: CAN, Ethernet, Mikrokontroller AVR und ARM, Linearregler 1,8V 3,3V 5V in SOT223
* Leerplatinen, Bausätze
* günstig
* Abholung in Hattingen möglich
* Versandkosten innerhalb Deutschlands ab 2,50€
* keine Kreditkartenzahlung möglich

=== Mikrocontroller.net ===
Homepage: http://shop.mikrocontroller.net

* Starterkits, Development Boards und Zubehör für AVR, AVR32, ARM und MSP430

=== Mira Nürnberg ===
Homepage: http://www.mira-electronic.de

* SMD-Bauteile, SMD-Sortimentboxen
* Verkauf und Preisangaben nur für Gewerbetreibende

=== Karl Müller EME Messtechnik ===
Homepage: http://www.eme-hf-technik.de

* Hochfrequenz-Messtechnik, HF-Komponenten

=== Mouser ===
Homepage: http://de.mouser.com

* Liefert an Privat
* Zügige Lieferung mit FedEx aus den USA
* Keine Halbleiter von Linear, National und Analog

=== MS-Elektronik ===
Homepage: http://www.ms-elektronik.info

* Liefert an Privat
* Zügige Lieferung
* Gute Qualität
* Viel in Richtung Audio
* Große Auswahl an Elkos -> kleine Preise
* kein allzu großes Sortiment

=== Mütron ===
Homepage: http://www.muetronshop.de

* Keine Privatkunden

=== myAVR Shop ===
Hompage http://shop.myavr.de

* Kleine Auswahl, aber die angebotene Ware ist sehr preiswert (meist preiswerter als bei Reichelt)
* Zügige Lieferung (1-2 Werktage)
* Diverse Zahlungsmöglichkeiten: Rechnung, Vorkasse, Lastschrift, Kreditkarte, PayPal
* Kein Mindestbestellwert
* Sehr günstige Versandkosten ab 1,95 Eur
* Mengenrabatt ab 10 gleichen Artikeln

=== Neuhold-Elektronik ===
Homepage: http://www.neuhold-elektronik.at 
Shop: http://www.neuhold-elektronik.at/catshop/default.php?language=de

* preiswerte Schnäppchen
* regelmäßig aktualisierte Angebotsliste herunterladbar
* Ab 60,- EUR versandkostenfrei in Österreich

=== Octamex ===
Homepage: http://www.octamex.de

* preiswerte Leiterplattenchemie
* Chemisch Zinn
* Ätzmittel Natriumpersulfat, Eisen-III-Chlorid
* Entwickler positiv und negativ
* Lötstopp-Laminat, Tentingresist, Bestückungsdruck
* Bungard Basismaterial in 0,5mm 1,0mm 1,5mm Dicke und 18µm, 35µm, 70µm Kupfer
* Bungard Alucorex für 19" Frontplatten
* Gehäuse aller Art
* Quarze in Industriequalität
* aktive und passive Halbleiter (Widerstände, Kondensatoren, Transistoren, Logik-ICs etc.)
* kein Mindestbestellwert
* Lieferung auch ins Ausland
* Versandkosten ab 2,55EUR
* Liefert nur gegen Vorkasse, ausser für Bestandskunden, die schon häufig bestellt haben
* Zahlung mit EC-Pay oder Kreditkarte nur gegen erheblichen Aufschlag (bis zu 5%)

=== Online Batterien ===
Homepage: http://www.online-batterien.de

* Allerlei günstige Batterien & Akkus vieler Marken
* z. B. '''40 Stk.''' DURACELL PLUS LR6 AA 11,59€ (Jan 2010)
* Beleuchtungsartikel
* USV
* Versand ab 3,90€

=== Oppermann ===
Homepage: http://www.oppermann-electronic.de

* Restposten, auch HF Bauteile
* auch Privatkunden
* Lieferung nach üblicher Zeit

=== PCB-Soldering ===

Homepage, Online-Shop: http://www.pcb-soldering.co.uk
eBay: http://www.allendale-stores.co.uk
Firmen-Homepage: http://www.allendale-elec.co.uk

* [http://www.aoyue.com/en/products.asp Aoyue] Lötstationen und preiswertes Zubehör (Lötspitzen) für diese. Bei Aoyue-Zubehör bessere Preise (Stand 10/2008) als [[#WilTec_Wildanger_Technik_GmbH|WilTec]]
* Schnelle Lieferung
* Dank [http://www.zoll.de/b0_zoll_und_steuern/a0_zoelle/a1_grundlage_zollrecht/b0_zollgebiet/index.html EU Binnenmarkt] nur britische Mehrwertsteuer (VAT), kein Zoll, keine [http://www.zoll.de/b0_zoll_und_steuern/a3_einfuhrumsatzsteuer/index.html Einfuhrumsatzsteuer] fällig.
* Zwei von drei E-Mails wurden nicht beantwortet
* Versandart wurde eigenmächtig von "Standard" auf teureres "Signed for" (Einschreiben) geändert

=== Pollin Electronic ===
Homepage: http://www.pollin.de

* Günstige Restposten aller Art (z. B. "250 g verschiedene ICs" u.dgl.)
* Produktkategorien:
** Computer und Zubehör
** Telefone und Zubehör
** Antennentechnik
** HiFi/Car-HiFi/Video/TV
** Stromversorgung
** Lichttechnik
** Messtechnik / Uhren
** Haustechnik
** Werkstatt
** Bauelemente
** KFZ- und Zweirad
** Motoren
** Bausätze
** Fundgrube
* Produkte teils schnell ausverkauft
* Qualität schwankend. Man kann gute Schnäppchen machen aber auch reinfallen. Umtausch ist dann aber problemlos.
* Es wird öfters von sorgloser Verpackung berichtet, trotz Verpackungspauschale von 0,85 % des Warenwerts (empfindliche und schwere Produkte besser nicht zusammen bestellen). Reklamationen bei Beschädigungen werden freundlich behandelt.
* Lieferzeit i.d.r. 2-3 Werktage / knappe Woche bei neuer Sonderliste
* Ladengeschäft in 85104 Pförring
* Versandkosten innerhalb Deutschlands 4,50 € (ab 150€ versandkostenfrei); dazu 0,85 % Verpackungspauschale
* Zahlung per Nachnahme (+2,50 €) oder Bankeinzug (keine Kreditkarte, keine Überweisung)

=== proma / Isel ===
Homepage: http://www.proma-technologie.com/deutsch/rundum_l/proma_fs_1.html

* fotobeschichtete Leiterplatten Platinenfrästechnik
* Chemikalien für die Platinenherstellung: Ätzmittel, Flussmittel für Lötanlagen, etc.
* Profilgehäuse, u.a. von Conrad und Reichelt vertrieben

=== QRP-project ===
Homepage: http://www.qrpshop.de/sitemap.htm
* Bausätze vor allem einfache Kurzwellen-Funkgeräte

=== Reichelt ===
Homepage: http://www.reichelt.de

* relativ große Auswahl, aber nicht viele "brandaktuelle" Bauteile
* wenn man höflich fragt, liefern sie ganz selten auch Bauteile, die nicht im Katalog stehen zu "normalen" Preisen (vorausgesetzt der Hersteller ist im Sortiment), z. B. Xilinx XC2S50, aber meist erhält man die Antwort, dass der Artikel nicht im Sortiment ist, obwohl auf der Homepage unter Service extra ein Punkt angeführt ist: "Ich benötige einen Artikel, der nicht im Programm ist"
* reagiert aber teilweise auch auf Anregungen, neue Produkte in das Angebot aufzunehmen; siehe dazu auch den Artikel [[Reichelt-Wishlist]]
* liefert schnell und vollständig; wenn etwas ausnahmsweise nicht verfügbar ist, dann liefern sie es auf eigene Kosten nach, wenn der Artikel in absehbarer Zeit wieder vorrätig ist (selbst wenn er nur 0,20€ wert ist).
* lässt einen dennoch manchmal warten, wenn ein Artikel nicht lieferbar ist! Daher bei der Bestellung immer darauf hinweisen, dass man auch eine Teillieferung akzeptiert. (Laut Auskunft dauert das länger, besser nach der Inet-Bestellung anrufen und nicht lieferbare Teile aus der Bestellung streichen lassen)
* Lieferzeiten normalerweise 2 - 4 Arbeitstage
* niedrige Preise (aber unbedingt Qualität des Artikel checken)
* Versandkosten 5,60€ (Deutschland); 10€ Österreich; Schweiz 16€; EU 15 - 19€;
* 10€ Mindestbestellwert für alle Länder
* auch in die Schweiz sehr guter Service
* holt sich auch ohne Erlaubnis Bankauskünfte bei großen Bestellungen ein

=== RFW Elektronik ===
Homepage: http://www.rfw-elektronik.de

* HF Bauelemente

=== Ribu ===
Homepage: http://www.ribu.at

* Sehr guter Elektronikversand in Österreich mit zahlreichen Entwicklungsboards und zahlreichen Elektroniklösungen.
* Liefert sehr schnell und hat eine ausgezeichnete Beratung.
* Online-Shop ist sehr übersichtlich und einfach zu bedienen.
* Lieferstatusanzeige für alle Artikel. Bei Auslaufartikeln ist sogar die noch verfügbare Stückzahl sichbar.
* Günstige Sonderangebote
* innerhalb Österreichs 4,90€ Versandkosten, ab 80,- keine Versandkosten
* ausserhalb Österreichs 13€ Versandkosten, ab 225€ versandkostenfrei
* liefert auch an Privatkunden
* Mindestbestellwert innerhalb Österreichs 10€, ausserhalb 30€

=== Richardson Electronic ===
Homepage: http://www.rell.com/international/index.asp?ID=GE

* Hochfrequenz-Halbleiter, HF-Röhren,

=== Riedl Elektronik ===
Homepage: http://www.riedl-electronic.at

* großes Angebot v.a. ICs und Trafos
* recht günstig
* Rabatt für Schüler/Student
* Versand nach AT: 3,95€ bis 1kg, ab 100€ frei Haus
* Versand AT über 1kg sowie Ausland: Nach Aufwand (wird nicht direkt angezeigt)

=== RLX COMPONENTS s.r.o. ===
Homepage: http://www.rlx.sk

* Man spricht Deutsch
* Messgeräte, Mikrocontroller-Boards, Bauelemente

=== RM Computertechnik GmbH ===
Homepage: http://www.rm-computertechnik.de

* Kerngeschäft ist PC-Technik, aber auch großes Sortiment an Kabeln, Litzen und Steckverbindern
* handelt auch mit einigen Bauelementen, wie LED's

=== Robotikhardware===
Homepage: http://www.robotikhardware.de

* Microcontroller
* Entwicklungsboards
* Sensoren
* Robotik-Zubehör
* günstiges Angebote für Hobby-Elektroniker
* auch einzelne Platinen

=== Benno Rößle Elektronik ===
Homepage: http://www.roessle-elektronik.de

* Masten, Antennen, Befestigungsmat.,Zubehör, Geräte, Anpassteile, HF-Stecker

=== RS Components ===
Homepage: http://de.rs-online.com

* lt. AGB nur an gewerbliche Abnehmer, fragt bei Internetbestellungen aber nicht nach. Anm.: mitlerweile machen sie es doch.
* gute Auswahl insbesondere an "mechanischen Bauteilen"
* gute Verfügbarkeit
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (GP)
* Preise wurden angepasst, gute Preis/Leistung
* Preis im Onlineshop sind ohne MwSt angegeben
* Bei Onlinekauf ist der Versand kostenfrei, ohne Mindesbestellwert.
* Notify-Me Service für Produktabkündigung
* Auch größere Stückzahlen über Allied möglich
* Relativ große Auswahl an Sortimenten (Widerstände, Kondensatoren), Einzelteile können teilweise nachgekauft werden
* Verfügbarkeitsanzeige im Internet ist ziemlich hilfreich
* Nützliche Tipps zum Thema RoHS

=== Sander Elektronik ===
Homepage: http://www.sander-electronic.de

* beliefert auch Privatkunden, Bankeinzug möglich
* ähnlich Segor ein Berliner Versender
* Hier findet man manche [[MSP430]], die es sonst nicht in kleinen Stückzahlen gibt
* Herr Sander ist sehr kompetent und selbst Autor von Fachartikeln
* selbst abgekündigte Halbleiter können noch beschafft werden
* Bezahlung auch mit Kreditkarte möglich
* Versandkosten innerhalb Deutschlands ab 3,35€, innerhalb Europas ab 6€

=== Sasco Holz ===
Homepage: http://www.sasco.de

* Wie Spoerle eine Tochter von Arrow.
* Distributor für Analog Devices...
* Liefert wie Spoerle und Arrow in Deutschland nicht an Privatkunden.

=== Sat-Schneider ===
Homepage: http://www.sat-schneider.de
* Bauteile, Ersatzteile Online-Shop
* Baugruppen zum Empfang des Digitalen Kurzwellenrundfunks DRM

=== Otto Schubert GmbH ===
Homepage: http://www.schubert-gehaeuse.de

* Kein Online-Shop. Bestellungen nur per Telefon, Fax oder E-Mail
* Weissblechgehäuse, Gerätegehäuse, wetterfeste Gehäuse
* Drehkondensatoren
* Sonderanfertigungen

=== Schramm-Software ===
Homepage: http://www.schramm-software.de/bausatz/
* Online-Shop, bietet Elektronik-Bausätze mit Mikrocontrollern
* Bausätze als Lehrmaterial geeignet, da ausführliches Begleitheft mitgeliefert wird (Aufbauanleitung, Schaltung, Controllerprogramm, Experimente...)
* bisher nur ein relativ kleines Sortiment, soll ergänzt werden
* Versandkosten innerhalb Deutschlands 2,50 €, innerhalb der EU 3,50 €

=== Schukat elektronic ===
Homepage: http://www.schukat.de

* liefert nicht an privaten Endverbraucher
* einfache und passiver Bauteile oft nur in großen Mindeststückzahlen
* ICs teilweise recht preiswert (vor allem bei mehr als 1 Stück, z. B. auch AVR)
* LCDs sehr preiswert und auch als Einzelstücke
* aktuelle Preise und Verfügbarkeit im Internet (aber nur nach Anmeldung -jetzt nicht mehr bei kleinen Stückzahlen), ebenso Bilder von Gehäusefootprints u.dgl.
* Abholung in Monheim am Rhein nach Vereinbarung möglich
* Versandkosten innerhalb Deutschlands ab 5€ (bis 10kg!)

=== Schuricht ===
Homepage: http://www.schuricht.de

* deutscher Ableger der Distrelec- (Elektronik) und Disdata-Gruppe (Computertechnik)
* Liefert auch an Privatkunden (getrennte AGBs für gewerbliche und Privatkunden, Lieferung an Privat per Nachnahme: Versandkosten ab 6,54€ plus 4,76€ Nachnahmegebühr).
** Online-Bestellung von Privatkunde scheiterte daran, dass die Onlineshop-Bestellformulare nur für gewerbliche Kunden ausgelegt sind und der Onlineshop Bestellungen ohne Firmenangaben nicht annimmt oder gar mit einer internen Fehlermeldung quittierte.
**Online Bestellung mit "Privat" als Firmenangabe funktionierte einwandfrei.
**Telefonische Bestellung von Privat funktioniert. Nette, freundliche Behandlung am Telefon, kein Callcenter. Versprochener Rückruf erfolgte mit gewünschten Informationen. Neben Nachnahme wurde für einen relativ teuren Artikel persönliche Abholung angeboten. Angegebene Lieferfrist wurde leicht unterschritten.
* Papierkatalog über 2000 Seiten, durchgehend farbig, nur für Geschäftskunden erhältlich.
* Ziemlich teuer

=== Schuro Elektronik GmbH ===
Homepage: http://www.schuro.de

* Elektronische Bauelemente und Bauteile für den Audio- und Lautsprecherbau (Kondensatoren, Spulen u.dgl.)
* kein Mindestbestellwert
* Versandkosten innerhalb Deutschlands gewichtsabhängig ab 5,75€

=== Segor-electronics ===
Homepage: http://www.segor.de

* Spezialist für Halbleiter, die ansonsten für nicht-gewerbliche Abnehmer nur schwer erhältlich sind (Preise dahingehend "angemessen")
* auch Privatkunden gerne gesehen
* Ladengeschäft in Berlin
* kein Mindestbestellwert bei Versand innerhalb der EU

=== SE Spezial-Electronic AG ===
Homepage: http://www.spezial.de

* Distributor
* Laut AGB auch Verkauf an Privat.
* Große Verpackungseinheiten/Mindestbestellmengen pro Bauteil
* Versandkosten pauschal 9,- € (Deutschland) (Stand 08/2008)

=== Shortec Electronics ===
Homepage: http://www.shortec.com

* Unabhängiger Distributor von elektronischen und elektromechanischen Bauelementen aller Hersteller.

=== Small Control Shop ===
Homepage: http://www.small-control.de

* "Bernd Walter Computer Technology"
* kleines Lieferprogramm aber ein paar interessante Produkte

=== SMG Diffusion - F1GE ===
Homepage: http://www.smgdiffusion.com
( Seite nur französisch )

* Videotechnik,
* 1,2 GHz / 2,4GHz Module
* Gebraucht-Messgeräte HP, Tek, Philips u.a.
* GHz-Halbleiter
* Koax-Adapter
* Antennen

=== Spoerle ===
Homepage: http://www.spoerle.de

* Früher eine Tochterfirma von Arror. Mittlerweile komplett in Arrow aufgegangen, Webseite leitet auf Arrow um.
* Aus dem Webshop: "Unser Angebot richtet sich nur an Kaufleute und nicht an Verbraucher."
* Wenn es wirklich über Arrow sein muss, dann kann man es als Privatperson bei Arrow Electronics North American Components http://www.arrownac.com/ versuchen, die sich normalerweise nicht weigern ihre Produkte zu verkaufen. Allerdings muss man mit großen Mindestmengen (z. B. BC547 in Schritten von 2000 Stück) und hohen Kosten rechnen.
:Zu den Kosten gehören zum Beispiel ein mehrfacher Mindermengenzuschlag (''$10 handling charge will be added to each line item less than $30''), eine satte ''handling and energy fee of $10.22'' (mehr als 10x zu hoch wie die vergleichbare Gebühr für amerikanische Besteller), hohe Versandkosten (ab $20 nach Deutschland). Dazu kommen die üblichen Kosten für den Import aus dem Ausland (Einfuhrumsatzsteuer, Kreditkartengebühr, ...)

=== SR-Systems ===
Homepage: http://www.sr-systems.de

* Baugruppen für Digital-TV, Sende- und Empfangstechnik
* DVB-S, DVB-T

=== Strixner&Holzinger ===
Homepage: http://www.sh-halbleiter.de

* Ladengeschäft in München
* Versand
* riesiges Angebot an Halbleiter, auch schwer beschaffbare
* Online-Shop

=== TAUTEC-ELECTRONICS ===
Homepage: http://www.tautec-electronics.de

* Online Shop für aktive elektronische Bauelemente
* günstige Preise (Vorsicht, Preisangaben enthalten keine Mehrwertsteuer) aber Mindestbestellwert 100 Euro
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, Car-HiFi und TV-Bereich

=== TCB-Versand ===
Homepage: http://www.tcb-versand.de

* insbesondere für Modellbauer ein sehr interresantes Sortiment
* Stecker,Kabel etc. recht günstig und kleine Mengen abnehmbar
* Lieferung normal zwischen 1 und 3 Tage
* leider nur Online-Shop

=== Tec-Shop (Wolfgang Rompel Elektronik) ===
Homepage: http://www.tec-shop.de

* Kleines, aber ausgesuchtes Sortiment
* Interessantes Angebot an Sensoren

=== Technik-Welt / Industrieshop.at ===
Homepage: http://www.industrieshop.at

* Laut Homepage richtet man sich "an den industriellen Kunden". Laut AGB sieht man das jedoch nicht so eng, Zitat:
:: ''TW schließt online Verträge nur mit Kunden ab, die natürliche oder juristischen Personen sind, die ihren Wohnsitz oder Sitz in Österreich, einem Mitgliedsstaat der Europäischen Union (EU25) oder der Schweiz haben.''
* [[#Farnell|Farnell]] Teile
* In Österreich
* Schnelle Lieferung (2 Tage)

=== TIGAL KG ===
Homepage: http://www.tigal.com

* Boards und Tools für Embedded-Elektronik
* In Österreich
* Versandkosten ab € 7,00 in Österreich, ab € 10,00 nach Deutschland.
* Preisangaben ohne MWSt. Für Privatkunden kommen 20% österreichische Mehrwertsteuer hinzu.
* U.a. ZeroLogic Logik-Analysatoren.

=== TME (Transfer Multisort Elektronik) ===
Homepage: [http://www.tme.pl/index.phtml?lang=de www.tme.pl]

* Firmensitz in Łódź, Polen
* Zahlungsabwicklung über deutsches Konto
* als Privatkunde: Mehrwertsteuer beachten (22%)
* sehr großes günstiges SMD Sortiment

=== Trade-Shop / AIR Electronics GmbH ===
Homepage: http://www.trade-shop.de

* Trotz knackiger Sprüche auf der englischen Version der Webseite ("Electronic Components Superstore") eher kleines Angebot elektronischer Bauteile
* 20 Euro Mindestbestellmenge (Stand Februar 2008)
* ab 6,90 Euro Versandkosten (Deutschland, bis 1kg) (Stand Februar 2008)

=== Trenkenchu & Stadler GbR ===
Homepage: http://www.ts-audio.de

* die meisten Artikel sind deutlich teurer als der Marktpreis, nur bei exotischen Bauelementen kann man durchaus ein Schnäppchen machen

=== TV-Ersatzteile ===
Homepage: http://www.tversatzteile.de

* TV-, Audio-, Video-Ersatzteile, Aktive / Passive Bauteile
* Fernbedienungen Haushaltstechnik

=== UKW-Berichte ===
Homepage: http://www.ukw-berichte.de

* Antennen, Bauteile, Bausätze, Literatur für Amateurfunk

=== Voelkner ===
Homepage: Kein Link, entsprechend der Vorgabe des Betreibers der Voelkner Webseite im Impressum:
<blockquote>voelkner - direkt günstiger
 
wird produziert und betreut von 
Re-In Retail International GmbH 
... 
Eine Verlinkung auf die Website der Firma Re-In Retail International GmbH bedarf einer schriftlichen Genehmigung. </blockquote>

* Großer Teil des Conrad-Programms, identische Nummern, identische Aufkleber auf der Ware, Preise identisch oder nur ein paar Cent abweichend
* Versandkosten Deutschland: 4,95€; ab 25€ Warenwert und Sofortüberweisung.de versandkostenfrei / Versandkosten-Flatrate für 15€ pro Jahr
* Versandkosten EU: 9,95€
* Möglichkeit der Versandkostenflatrate (D): Einmalig 9,95€ / gültig für ein Jahr
* Legt jeder Bestellung gleich wieder einen Gutschein über 5€ bei MBW 25€ bei (Flat nur bei häufigen, kleinen Bestellungen sinnvoll); außerdem kommt etwa alle 2-3 Monate selbiger Gutschein + versandkostenfreie Lieferung per Mail, ebenfalls MBW 25€
* Verpackungsqualität wechselnd, mal brauchbar, mal eher Pollin-Niveau. Selbst kleine Bestellungen, die gefahrlos per Brief/Großbrief verschickt werden könnten werden in einem großen Paket versendet.

=== VOTI Webshop ===
Homepage: http://www.voti.nl/shop/catalog.html

* relativ kleines Lieferprogramm
* einige interessante Restposten (Surplus)

* Sitz in Amersfoort, Niederlande

=== Walter elektronik ===
Homepage: http://www.walter-elektronik.de

* Bauteile, Röhren

=== Watterott electronic GmbH===
Homepage: http://www.watterott.com

* Distributor für Arduino, BeagleBoard, FriendlyARM, Pololu, Seeed Studio, Solarbotics, SparkFun...vollständige [http://www.watterott.net/about#distri Liste hier]
* Entwicklungskits von Atmel, Luminary Micro, Microchip, Raisonance, TI
* Spezialbauteile von Davicom, FTDI, VLSI, WIZnet
* Bungard Basismaterial + Chemie
* kein Mindestbestellwert
* Zahlung: Vorkasse, Sofortüberweisung, PayPal, Nachnahme, Kreditkarte (Visa/Mastercard), Rechnung (nur gewerbliche Kunden)
* Versandkosten Dtl. (UPS):
** bis 25 EUR Warenwert: 3,50 Euro
** bis 50 EUR Warenwert: 2,90 Euro
** bis 150 EUR Warenwert: 2,00 Euro
** ab 150 EUR Warenwert: versandkostenfrei
* Versandkosten EU (UPS):
** bis 150 EUR Warenwert: 10,00 Euro
** bis 250 EUR Warenwert: 8,90 Euro
** bis 500 EUR Warenwert: 7,00 Euro
** ab 500 EUR Warenwert: versandkostenfrei
* Schneller, entgegenkommender Service

=== Westfalia ===
Homepage Deutschland: http://www.westfalia.de
Homepage Österreich: http://www.westfalia-versand.at

* Vor 85 Jahren in Hagen, Westfalen gegründet
* Elektronik nur ein kleiner Teil des Angebotes. Eher insgesamt Haushalts-, Werkstätten-, Agrar- und Gartenbedarf
* Elektroniksortiment stark schwankend. Momentan (Juni 2008) wenig Auswahl.
* Mindestbestellwert 18 €, bei Neukundenbestellungen mit Prämienanforderungen (wenig wertiges Geschenk) sogar 50 €.
* 4,95€ Versandkosten, ab 150€ Bestellwert versandkostenfrei
* Transportversicherung wird zusätzlich mit einem Zuschlag von 0,8% des Warenwertes berechnet.
* Einmalige Bestellung führte zu jahrelanger Zusendung von Werbung für Westfalia-Angeboten mit Gewinnspielen (Glücksnummern, Rubbellose, Glücksschlüssel, etc.)
* Verpackung ähnlich "sorgfältig" wie bei [[#Pollin_Electronic|Pollin Electronic]]. Übergroße Kartons, wenig Verpackungsmaterial, schweres Teil (Labornetzgerät) flog lose im Karton herum und zertrümmerte andere Ware.

=== WilTec Wildanger Technik GmbH ===
Homepage: http://shop.wiltec.info

* Aoyue Lötgeräte (Heißluft, Löten, Entlöten), Netzteile, Werkzeuge
* Aoyue Zubehör (Lötspitzen, Heißluftdüsen), Ersatzteile
* Andere, nicht Elektronik-Angebote, wie KFZ-Tuningteile
* Versand. Bei Voranmeldung auch Lagerverkauf.

=== Wüstens frag-jan-zuerst ===
Homepage: http://www.die-wuestens.de/dindex.htm

* Röhrentechnik
* Hochspannungs-Spezialteile

=== WIMO ===
Homepage: http://www.wimo.de

* Große Auswahl an Amateurfunktechnik

=== Zech DG0VE ===
Homepage: http://www.dg0ve.de

* Baugruppen für Amateurfunk

=== Diverse ===
* http://www.chip-flip.com - Europäisches Bauelementesuchsystem, franchised Lieferantensuche, Datenblätter und viele nützliche Informationen
* http://www.ecomponents-store.com/ Elektronische Bauelemente kaufen - Hier finden Sie eine große Auswahl an elektronischen und elektromechanischen Bauelementen von über 40 Herstellern.
* http://www.franchised-distributors.eu/ - Finden Sie Vertragsdistributoren von über 800 Halbleiterherstellern für elektronische und elektromechanische Bauelemente.

TODO: elektronik-fundgrube

==Messgeräte ==
=== Neue Messgeräte ===

Viele der oben genannten Elektronikversender verkaufen auch Messgeräte. Darüber hinaus gibt es diverse Versender, die sich hauptsächlich oder ausschließlich auf Messgeräte spezialisiert haben. Allerdings verkaufen viele davon nicht an Privat.

==== CalPlus GmbH ====
Homepage: http://www.calplus.de 
Shop: http://www.scopeshop.de

==== Cosinus ComputerMesstechnik ====
Homepage: http://www.cosinus.de

* Nicht an Privat

==== dataTec ====
Homepage: http://www.datatec.de

* Große Auswahl
* (Nicht an Privat) Bestellung von Privat problemlos möglich (11/2011)
* Studenten bekommen Rabatt, je nach dem, was bestellt wird
* Umständlicher Bestellvorgang, seitens DataTec teilweise auf dem Postweg -> Es dauert teil sehr lange bis die Ware ankommt
* Sehr freundlicher und kompetenter Service, per eMail als auch telefonisch

==== Donald4646 ====
Homepage: http://www.donald4646.co.uk

* In Schottland
* Als eBay-Shop gestartet
* Einfache, No-Name und Billigmarken (z. B. Oszilloskope)

==== Elektronik-Kontor Messtechnik GmbH ====
Homepage: http://www.ekomess.de

==== Meilhaus Electronic GmbH ====
Homepage: http://www.meilhaus.de

* Diverse Markenhersteller
* Eigenmarken

==== PinSonne-Elektronik ====
Homepage: http://www.pinsonne-elektronik.de

* Onlineshop
* Sehr kleines Sortiment
* UNI-T, RIGOL und andere asiatische Firmen

==== PK elektronik Poppe GmbH ====
Homepage: http://www.pk-elektronik.de

* U.a. Fluke Distributor.

====Präzitronic Hennig / Messgeräte Chemnitz====
Homepage: http://www.messgeraete-chemnitz.de

* Owon
* Selbst übersetzte deutsche Owon-Handbücher
* Fluke
* Zusätzlich kleines Angebot an Gebrauchtgeräten

==== ScopeShop Hamburg ====

* Von CalPlus übernommen, siehe [[#CalPlus_GmbH|CalPlus]]

==== SI Scientific Instruments GmbH ====
Homepage: http://www.si-scientific.de (Onlineshop) 
Homepage: http://www.si-gmbh.de (komplettes Programm)

* Onlineshop auf si-scientific.de
* Akzeptiert PayPal

==== SKY Messtechnik GmbH ====
Homepage: http://www.sky-messtechnik.de

* Kein Onlineshop (E-Mail oder Telefon)

==== TESTEC ====
Homepage: http://www.testec.info

* Tastköpfe-Hersteller
* Hameg Vertriebspartner
* B+K Precision Generalimporteur

==== Zeitech ====
Homepage: http://zeitech.eu/shop/

* Diverses (Rigol, Owon, etc.)

=== Gebrauchte Messgeräte ===

Dieser Abschnitt enthält Anbieter bei denen gebrauchte Messgeräte erhältlich sind.

==== Astro Electronic ====
Homepage: http://www.astro-electronic.de

==== eumex GmbH ====
Homepage: http://www.eumes.com/pub/de/

* Gebrauchte Messgeräte

==== HTB-Elektronik ====
Homepage: http://www.htb-elektronik.com

* Gebrauchte Messgeräte

==== IX Instrumex ====
Homepage: http://www.instrumex.de/index.cgi?User:LANGUAGE=de

* Gebrauchte Messgeräte

==== Christoph Lüders MessTechnik ====
Homepage: http://www.CLMT.de 
Online-Shop: http://www.shop-016.de/shop-CLMT.html 
eBay: http://myworld.ebay.de/c_h_r/

* Hat 2010 die Restbestände von Förtig übernommen

==== mbmt Messtechnik ====
Homepage: http://www.mbmt.com

* Gebrauchte Messgeräte
* Verkauf nur an Gewerbetreibende

==== Rosenkranz Elektronik ====
Homepage: http://www.rosenkranz-elektronik.de 
eBay Shop: http://stores.ebay.de/Rosenkranz-Elektronik-GmbH-Shop

* Gebrauchte Messgeräte
* Auch auf eBay zu finden

==== Helmut-Singer-Elektronik ====
Homepage: http://www.helmut-singer.de

* Gebrauchte Messgeräte
* Verkauf auch an Privat
* An den meisten Samstagen im Jahr auch Lagerverkauf, sonst Versand

==== Sphere ====
Homepage: http://www.sphere.bc.ca 
Messgeräte und Ersatzteile: http://www.sphere.bc.ca/test/index.html

* Gebrauchte Messgeräte
* Ersatzteile
** Besonders bekannt für Tektronix-Ersatzteile

==== Tektronix TekSelect ====
Homepage: http://www.tek.com/Measurement/tekselect/

* Tektronix verkauft selber gebrauchte und überarbeitete Tektronix-Messgeräte unter dem Label ''TekSelect''.
* Original Tektronix-Garantie
* Der Bestellvorgang nervt, man muss Kontaktaufnahme durch einen "Representative" erbeten.

== Siehe auch ==
* [[Platinenhersteller]]
* [[Lokale Elektroniklieferanten]]
* [[Eisenwarenversender]]

== Links ==

* http://www.xs4all.nl/~ganswijk/chipdir/ Suche nach integrierten Schaltkreisen
* http://www.alldatasheet.com Datenblätter

[[Kategorie:Bauteile|!]]
[[Kategorie:Lieferanten]]

AVR-Studio

2012-01-19T17:15:45Z

Mthomas: /* Debugger */

Das '''AVR-Studio''' ist eine kostenlose Entwicklungsumgebung ([[Editoren/IDEs|IDE]]) für die Programmierung der [[AVR]]-[[Mikrocontroller]] von Atmel. Sie basiert ab Version 5 auf der Visual Studio Shell von Microsoft und besteht aus einer Projektverwaltung, einem [[Editoren/IDEs#Texteditoren für Programmierer|Editor]], einem [[AVR-Studio#Debugger|Debugger]] und Werkzeugen zum beschreiben der Mikrocontroller.

Mit dem AVR Studio kann in [[Assembler]] sowie in [[C]]/[[C-Plusplus|C++]] programmiert werden. Für die Unterstützung von C/C++ musste bis einschließlich Version 4 vor der Installation des AVR Studio der GNU C Compiler für AVRs [[WinAVR]] installiert werden. Ab AVR Studio 5 ist eine vollständige Toolchain zur Entwicklung von C-Projekten enthalten. Atmel bietet weiterhin eine Erweiterung zwecks Erstellung von Projekten mit eingeschränkter C++-Unterstützung an (siehe [[AVR_Studio#Tipps_.26_Tricks|Tipps & Tricks]]).

== Debugger ==
Die AVR-Studio-Umgebung sieht unabhängig von der speziellen Debug-Plattform größtenteils identisch aus. Es existieren folgende Debug-Möglichkeiten:
# [[AVR-Simulation#AVR_Studio|AVR Simulator]]
# AVR In-Circuit Emulator / [[JTAG]]-Adapter: AVR Dragon, AVR ONE!, JTAGICE3, JTAGICE mkII
'''Simulation'''
* die meisten AVR-Mikrocontroller werden unterstützt
* z.T langsamer als eine Emulation (insbesondere bei größeren Projekten)
* Wechselwirkung mit Peripherie nur über vordefinierte Stimuli möglich
* Anzeige aller Register zu jeder Zeit möglich
'''Emulation'''
* Unterstützung von Mikrocontrollern plattformabhängig eingeschränkt
* z.T. schneller als Simulation
* Debugging in tatsächlicher Hardwareumgebung
* Register nicht uneingeschränkt lesbar

== Tipps & Tricks ==

* [[AVR-Studio Bugs]]

* [[AVR-Simulation]]

* [http://www.mikrocontroller.net/topic/193587#1894280 Pfad zum Hexfile]

* [http://www.mikrocontroller.net/topic/237681#2411339 Anzeige der Größe benutzter Speicherbereiche in AVR Studio 5]

* [http://www.mikrocontroller.net/topic/236601#2413654 C++ Templates (beta) für AVR Studio 5] (Vorsicht: kein vollständiger Funktionsumfang, siehe [http://support.atmel.no/bin/customer.exe?=&action=viewKbEntry&id=1001 FAQ])

* [http://www.rn-wissen.de/index.php/AVR_Studio_5#Eigene_Templates_erzeugen Erstellung eigener Templates in AVR Studio 5]

== Downloads ==

=== Offizielle Seite ===
* http://www.atmel.com/avrstudio

=== Direktlinks Installer ===

Anm.: Die MD5 Checksumme dient zum Überprüfen der Downloads auf Vollständigkeit. Die aktuelle Version ist '''fett''' markiert.

Im Falle nicht eingepflegter Updates hier der Direktlink-Präfix (entsprechenden Dateinamen aus dem Formularlink kopieren und hinter dem letzten Schrägstrich einfügen):

http://www.atmel.com/dyn/resources/prod_documents/

*[http://www.atmel.com/dyn/resources/prod_documents/as5installer-5.1.148.beta-full.exe as5installer-5.1.148.beta-full.exe] AVR Studio 5.1 Beta installer (includes VSS and .NET) (523 MB, updated 2011/12)

*[http://www.atmel.com/dyn/resources/prod_documents/as5installer-5.1.148.beta-small.exe as5installer-5.1.148.beta-small.exe] AVR Studio 5.1 Beta installer (308 MB, updated 2011/12)

*[http://www.atmel.com/dyn/resources/prod_documents/as5installer-full-5.0.1223.exe as5installer-5.0.1223-full.exe] '''AVR Studio 5 installer (includes VSS and .NET) (605MB, updated 2011/11/25)'''

*[http://www.atmel.com/dyn/resources/prod_documents/as5installer-small-5.0.1223.exe as5installer-5.0.1223-small.exe] '''AVR Studio 5 installer (390 MB, updated 2011/11/25)'''

*[http://www.atmel.com/dyn/resources/prod_documents/as5installer-5.0.1163-full.exe as5installer-5.0.1163-full.exe] AVR Studio 5 installer (includes VSS and .NET) (602MB, updated 2011/05/11) MD5:3C9371A8CF8A5D9663C107D00A22B6F1

*[http://www.atmel.com/dyn/resources/prod_documents/as5installer-5.0.1163-small.exe as5installer-5.0.1163-small.exe] AVR Studio 5 installer (387 MB, updated 2011/05/11) MD5:E0BD9F82DDDCF74B05C6BA1582F2C642

*[http://www.atmel.com/dyn/resources/prod_documents/avrstudio5.0.beta2.noVSSnoDotNet.exe Avrstudio5.0.beta2.noVSSnoDotNet.exe] AVR Studio 5.0 Beta 2 ohne Visual Studio Shell und .NET (339 MB)

*[http://www.atmel.com/dyn/resources/prod_documents/avrstudio5.0.beta2.exe AvrStudio5.0.beta2.exe] AVR Studio 5.0 Beta 2 (554 MB)

*[http://www.atmel.com/dyn/resources/prod_documents/avrstudio5.0.beta.exe AvrStudio5.0.beta.exe] AVR Studio 5.0 Beta (523 MB)

*[http://www.atmel.com/dyn/resources/prod_documents/AvrStudio4Setup.exe AvrStudio4Setup.exe] '''AVR Studio 4.19 (build 730) (124 MB, updated 2011/09/11)''' MD5:609209DB9A1C6191945421299101DC15

*[http://distribute.atmel.no/tools/avr/beta/4.19%20Build720/AvrStudio4Setup.exe AvrStudio4Setup.exe] AVR Studio 4.19 Beta (build 720) (123 MB, updated 2011/04/11) MD5:?

*[http://www.atmel.com/dyn/resources/prod_documents/AvrStudio417Setup.exe AvrStudio417Setup.exe] AVR Studio 4.17 (build 666) (112 MB, updated 07/09) MD5:9705a9362da76aa9779322127640a184

*[http://www.atmel.com/dyn/resources/prod_documents/AvrStudio416Setup.exe AvrStudio416Setup.exe] AVR Studio 4.16 (build 628) (126 MB, updated 02/09) (last version for Win98) MD5:d1c412d7a05a9ad95486d7ea680f68e5

*[http://www.atmel.com/dyn/resources/prod_documents/aStudio4b623.exe aStudio4b623.exe] AVR Studio 4.15 (build 623) (94 MB, updated 11/08)

*[http://www.atmel.com/dyn/resources/prod_documents/aStudio4b589.exe aStudio4b589.exe] AVR Studio 4.14 (build 589) (89 MB, updated 04/08)

*[http://www.atmel.com/dyn/resources/prod_documents/aStudio4b528.exe aStudio4b528.exe] AVR Studio 4.13 (build 528) (73 MB, updated 03/07)

=== Direktlinks Zusatzsoftware ===

*[http://www.atmel.com/dyn/resources/prod_documents/AVRQTouchStudioSetup_VSS_dotNET.exe AVRQTouchStudioSetup_VSS_dotNET.exe] AVR QTouch Studio mit .NET (373 MB, updated 03/10)

*[http://www.atmel.com/dyn/resources/prod_documents/avr-toolchain-installer-3.3.0.710-win32.win32.x86.exe avr-toolchain-installer-3.3.0.710-win32.win32.x86.exe] '''AVR Toolchain 3.3.0 (94 MB, updated 2011/09/11, AVR-GCC: 4.5.1, AVR-LIBC: 1.7.1)''' MD5: 1c43bac156cb1e4cb77dfc7a833cf237

*[http://www.atmel.com/dyn/resources/prod_documents/avr-toolchain-installer-3.2.3.579-win32.win32.x86.exe avr-toolchain-installer-3.2.3.579-win32.win32.x86.exe] AVR Toolchain 3.2.3 (95 MB, updated 06/11, AVR-GCC: 4.5.1, AVR-LIBC: 1.7.1)

*[http://www.atmel.com/dyn/resources/prod_documents/avr-toolchain-installer-3.0.0.240-win32.win32.x86.exe avr-toolchain-installer-3.0.0.240-win32.win32.x86.exe] AVR Toolchain 3.0.0 (87 MB, updated 09/10, AVR-GCC: 4.4.3, AVR-LIBC: 1.7.0) MD5:999B3DC3DF471B3A667CF0FE90A522E8. Update util/delay.h [http://www.mikrocontroller.net/topic/196738#1943039] beachten.

* [http://www.atmel.com/dyn/resources/prod_documents/asf-standalone-archive-2.9.0.zip asf-standalone-archive-2.9.0.zip] '''AVR SoftwareFramework 2.9.0 - drivers and libraries (80 MB, revision 2.9.0, updated 2012/01/19)'''

* [http://www.atmel.com/dyn/resources/prod_documents/asf-standalone-archive-2.6.1.33.zip asf-standalone-archive-2.6.1.33.zip] AVR SoftwareFramework 2.6.1.33 - drivers and libraries

*[http://www.atmel.com/dyn/resources/prod_documents/AVR-SoftwareFramework-2.3.1.zip AVR-SoftwareFramework-2.3.1.zip] AVR SoftwareFramework 2.3.1 - drivers and libraries

* [http://www.atmel.com/dyn/resources/prod_documents/AVRStudio5-ASF-Update-2.8.1.76.exe AVRStudio5-ASF-Update-2.8.1.76.exe] '''AVRStudio5-ASF-Update-2.8.1.76 (222 MB, revision 2.8.1, updated 2011/10/11)'''

* [http://www.atmel.com/dyn/resources/prod_documents/AVRStudio5-ASF-Update-2.7.0.43.exe AVRStudio5-ASF-Update-2.7.0.43.exe] AVRStudio5-ASF-Update-2.7.0.43 (214 MB, revision 2.7.0, updated 2011/8/11)

* [http://www.atmel.com/dyn/resources/prod_documents/AVRStudio5-ASF-Update-2.6.1.27.exe AVRStudio5-ASF-Update-2.6.1.27.exe] AVRStudio5-ASF-Update-2.6.1.27

* [http://www.atmel.com/dyn/resources/prod_documents/AVR2025_MAC_v_2_7_0.exe AVR2025_MAC_v_2_7_0.exe] IEEE 802.15.4 MAC Stack

== Weblinks ==
* [http://www.youtube.com/user/AtmelCorporation#g/c/8F325BE889E62E50 YouTube-Playlist: AVR Studio 5 Tutorial]

* [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=82994 How to install JTAGICE mkII (and AVR Dragon and AVRISP mkII) on Windows 7 x64] auf avrfreaks.net (ggf. kostenlos registrieren). Siehe auch Hinweis von Denny [http://www.mikrocontroller.net/topic/146857#1476962] im Forum.

*[http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR Eclipse Plugin]

*[http://avrstudio5.wordpress.com/ AVR Studio 5 Blog] - Useful hints and tips for installation troubleshooting with the new AVR Studio 5

[[Category:AVR]]
[[Kategorie:Entwicklungstools]]

AVR-GCC-Tutorial

2012-01-19T17:08:26Z

Mthomas: /* Nutzung des ADC */

= Voraussetzungen =

Vorausgesetzt werden Grundkenntnisse der Programmiersprache C. Diese Kenntnisse kann man sich online erarbeiten, z. B. mit dem [http://www.schellong.de/c.htm C Tutorial von Helmut Schellong] ([[C|Liste von C-Tutorials]]). Nicht erforderlich sind Vorkenntnisse in der Programmierung von Mikrocontrollern, weder in Assembler noch in einer anderen Sprache.

= Vorwort =

Dieses Tutorial soll den Einstieg in die Programmierung von Atmel [[AVR]]-Mikrocontrollern in der Programmiersprache [[C]] mit dem freien C-Compiler [[AVR-GCC]] aus der [http://gcc.gnu.org/ GNU Compiler Collection] erleichtern.

In diesem Text wird häufig auf die Standardbibliothek avr-libc verwiesen, für die es eine [http://www.nongnu.org/avr-libc/user-manual/index.html Online-Dokumentation] gibt, in der sich auch viele nützliche Informationen zum Compiler und zur Programmierung von AVR Controllern finden (beim Paket WinAVR gehört die avr-libc Dokumentation zum Lieferumfang und wird mitinstalliert).

Der Compiler und die Standardbibliothek avr-libc werden stetig weiterentwickelt. Einige Unterschiede, die sich im Verlauf der Entwicklung ergeben haben, werden im Haupttext und Anhang zwar erläutert, Anfängern sei jedoch empfohlen, die aktuellen Versionen zu nutzen (für MS-Windows: aktuelle Version des [[WinAVR]]-Pakets; für Linux: siehe Artikel [[AVR und Linux]]).

Das ursprüngliche Tutorial stammt von Christian Schifferle, viele neue Abschnitte und aktuelle Anpassungen von Martin Thomas.

Dieses Tutorial ist in PDF-Form hier erhältlich (nicht immer auf aktuellem Stand):
[[Media:AVR-GCC-Tutorial.pdf]]

== Weiterführende Kapitel ==

Um dieses riesige Tutorial etwas überschaubarer zu gestalten, wurden einige Kapitel ausgelagert, die nicht unmittelbar mit den Grundlagen von avr-gcc in Verbindung stehen. All diese Seiten gehören zur [[:Kategorie:avr-gcc Tutorial]].
: → [[AVR-GCC-Tutorial/Der UART|Der UART]]
: → [[AVR-GCC-Tutorial/Der Watchdog|Der Watchdog]]
: → [[AVR-GCC-Tutorial/Die Timer und Zähler des AVR|Die Timer und Zähler des AVR]]
: → [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]]
: → [[AVR-GCC-Tutorial/LCD-Ansteuerung|LCD-Ansteuerung]]
: → [[AVR-GCC-Tutorial/Alte Quellen|Alte Quellen anpassen]]
: → [[AVR-GCC-Tutorial/Assembler und Inline-Assembler|Assembler und Inline-Assembler]]

= Benötigte Werkzeuge =

Um eigene Programme für AVRs mittels avr-gcc/avr-libc zu erstellen und zu testen, wird folgende Hard- und Software benötigt:

* Platine oder Versuchsaufbau für die Aufnahme eines AVR Controllers, der vom avr-gcc Compiler unterstützt wird (alle ATmegas und die meisten AT90, siehe Dokumentation der avr-libc für unterstützte Typen). Dieses Testboard kann durchaus auch selbst gelötet oder auf einem Steckbrett aufgebaut werden. Einige Registerbeschreibungen dieses Tutorials beziehen sich auf den inzwischen veralteten AT90S2313. Der weitaus größte Teil des Textes ist aber für alle Controller der AVR-Familie gültig. Brauchbare Testplattformen sind auch das [[STK500]] und der [[AVR Butterfly]] von Atmel. Weitere Infos findet man in den Artikeln [[AVR#Starterkits|AVR Starterkits]] und [[AVR-Tutorial: Equipment]].

* Der avr-gcc Compiler und die avr-libc. Kostenlos erhältlich für nahezu alle Plattformen und Betriebssysteme. Für MS-Windows im Paket [[WinAVR]]; für Unix/Linux siehe auch Hinweise im Artikel [[AVR-GCC]] und im Artikel [[AVR und Linux]].

* Programmiersoftware und -[[AVR In System Programmer |hardware]] z. B. PonyProg (siehe auch: [[Pony-Prog Tutorial]]) oder [[AVRDUDE]] mit [[STK200]]-Dongle oder die von Atmel verfügbare Hard- und Software ([[STK500]], Atmel AVRISP, [[AVR-Studio]]).

* Nicht unbedingt erforderlich, aber zur Simulation und zum Debuggen unter MS-Windows recht nützlich: [[AVR-Studio]] (siehe Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]]).

* Wer unter Windows und Linux gleichermassen entwickeln will, der sollte sich die [http://www.eclipse.org/ IDE Eclipse for C/C++ Developers] und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin ] ansehen, beide sind unter Windows und Linux einfach zu installieren. Hier gibt es auch einen [[AVR_Eclipse|Artikel AVR Eclipse]] in dieser Wiki. Ebenfalls unter Linux und Windows verfügbar ist die Entwicklungsumgebung [http://www.codeblocks.org/ Code::Blocks] (aktuelle, stabile Versionen sind als Nightly Builds regelmäßig im [http://forums.codeblocks.org/ Forum] verfügbar). Innerhalb dieser Entwicklungsumgebung können ohne die Installation zusätzlicher Plugins "AVR-Projekte" angelegt werden. Für Linux gibt es auch noch das [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=25220&postdays=0&postorder=asc&start=0 KontrollerLab].

= Was tun, wenn's nicht klappt? =

* Herausfinden, ob es tatsächlich ein avr(-gcc) spezifisches Problem ist oder nur die eigenen C-Kenntnisse einer Auffrischung bedürfen. Allgemeine C-Fragen kann man eventuell "beim freundlichen Programmierer zwei Büro-, Zimmer- oder Haustüren weiter" loswerden. Ansonsten: [[C]]-Buch (gibt's auch "gratis" online) lesen.

* Die [[AVR Checkliste]] durcharbeiten.

* Die '''[http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc]''' lesen, vor allem (aber nicht nur) den Abschnitt Related Pages/'''Frequently Asked Questions''' = Oft gestellte Fragen (und Antworten dazu). Z.Zt leider nur in englischer Sprache verfügbar.

* Den Artikel [[AVR-GCC]] in diesem Wiki lesen.

* Das [http://www.mikrocontroller.net/forum/gcc GCC-Forum auf www.mikrocontroller.net] nach vergleichbaren Problemen absuchen.

* Das avr-gcc-Forum bei [http://www.avrfreaks.net AVRfreaks] nach vergleichbaren Problemen absuchen.

* Das [http://lists.gnu.org/archive/html/avr-gcc-list/ Archiv der avr-gcc Mailing-Liste] nach vergleichbaren Problemen absuchen.

* Nach Beispielcode suchen. Vor allem im ''Projects''-Bereich von [http://www.avrfreaks.net AVRfreaks] (anmelden).

* Google oder yahoo befragen schadet nie.

* Bei Problemen mit der Ansteuerung interner AVR-Funktionen mit C-Code: das Datenblatt des Controllers lesen (ganz und am Besten zweimal). Datenblätter sind auf den [http://www.atmel.com Atmel Webseiten] als pdf-Dateien verfügbar. Das komplette Datenblatt (complete) und nicht die Kurzfassung (summary) verwenden.

* Die Beispielprogramme im [[AVR-Tutorial]] sind zwar in AVR-Assembler verfasst, Erläuterungen und Vorgehensweisen sind aber auch auf C-Programme übertragbar.

* Einen Beitrag in eines der Foren oder eine Mail an die Mailing-Liste schreiben. Dabei möglichst viel Information geben: Controller, Compilerversion, genutzte Bibliotheken, Ausschnitte aus dem Quellcode oder besser ein [http://www.mikrocontroller.net/topic/72767#598986 Testprojekt] mit allen notwendigen Dateien, um das Problem nachzuvollziehen, sowie genaue Fehlermeldungen bzw. Beschreibung des Fehlverhaltens. Bei Ansteuerung externer Geräte die Beschaltung beschreiben oder skizzieren (z. B. mit [http://www.tech-chat.de/ Andys ASCII Circuit]). Siehe dazu auch: '''[http://www.tty1.net/smart-questions_de.html "Wie man Fragen richtig stellt"]'''.

= Erzeugen von Maschinencode =

Aus dem C-Quellcode erzeugt der avr-gcc Compiler (zusammen mit Hilfsprogrammen wie z. B. Präprozessor, Assembler und Linker) Maschinencode für den AVR-Controller. Üblicherweise liegt dieser Code dann im Intel Hex-Format vor ("Hex-Datei"). Die Programmiersoftware (z. B. [[AVRDUDE]], PonyProg oder AVRStudio/STK500-plugin) liest diese Datei ein und überträgt die enthaltene Information (den Maschinencode) in den Speicher des Controllers. Im Prinzip sind also "nur" der avr-gcc-Compiler (und wenige Hilfsprogramme) mit den "richtigen" Optionen aufzurufen, um aus C-Code eine "Hex-Datei" zu erzeugen. Grundsätzlich stehen dazu zwei verschiedene Ansätze zur Verfügung:

* Die Verwendung einer integrierten Entwicklungsumgebung (IDE = '''I'''ntegrated '''D'''evelopment '''E'''nvironment), bei der alle Einstellungen z. B. in Dialogboxen durchgeführt werden können. Unter Anderem kann AVRStudio ab Version 4.12 (kostenlos auf [http://www.atmel.com/ atmel.com]) zusammen mit WinAVR als integrierte Entwicklungsumgebung für den Compiler avr-gcc genutzt werden (dazu müssen AVRStudio und WinAVR auf dem Rechner installiert sein). Weitere IDEs (ohne Anspruch auf Vollständigkeit): [http://www.eclipse.org/ Eclipse for C/C++ Developers] (d.h. inkl. CDT) und das [http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin AVR-Eclipse Plugin] (für diverse Plattformen, u.a. Linux und MS Windows, IDE und Plugin kostenlos), [http://sourceforge.net/projects/kontrollerlab KontrollerLab] (Linux/KDE, kostenlos). [http://www.atmanecl.com/EnglishSite/SoftwareEnglish.htm AtmanAvr] (MS Windows, relativ günstig), KamAVR (MS-Windows, kostenlos, wird augenscheinlich nicht mehr weiterentwickelt), [http://www.amctools.com/vmlab.htm VMLab] (MS Windows, ab Version 3.12 ebenfalls kostenlos). Integrierte Entwicklungsumgebungen unterscheiden sich stark in Ihrer Bedienung und stehen auch nicht für alle Plattformen zur Verfügung, auf denen der Compiler ausführbar ist (z. B. AVRStudio nur für MS-Windows). Zur Anwendung des avr-gcc Compilers mit IDEs sei hier auf deren Dokumentation verwiesen.

* Die Nutzung des Programms make mit passenden Makefiles. In den folgenden Abschnitten wird die Generierung von Maschinencode für einen AVR ("hex-Datei") aus C-Quellcode ("c-Dateien") anhand von "make" und den "Makefiles" näher erläutert. Viele der darin beschriebenen Optionen findet man auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio (AVRStudio generiert ein makefile in einem Unterverzeichnis des Projektverzeichnisses).

Beim Wechsel vom makefile-Ansatz nach WinAVR-Vorlage zu AVRStudio ist darauf zu achten, dass AVRStudio (Stand: AVRStudio Version 4.13) bei einem neuen Projekt die Optimierungsoption (vgl. Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|AVR-GCC-Tutorial/Exkurs: Makefiles]], typisch: -Os) nicht einstellt und die mathematische Bibliothek der avr-libc (libm.a, Linker-Option -lm) nicht einbindet. (Hinweis: Bei Version 4.16 wird beides bereits gesetzt). Beides ist Standard bei Verwendung von makefiles nach WinAVR-Vorlage und sollte daher auch im Konfigurationsdialog des avr-gcc-Plugins von AVRStudio "manuell" eingestellt werden, um auch mit AVRStudio kompakten Code zu erzeugen.

= Einführungsbeispiel =

Zum Einstieg ein kleines Beispiel, an dem die Nutzung des Compilers und der Hilfsprogramme (der sogenannten ''Toolchain'') demonstriert wird. Detaillierte Erläuterungen folgen in den weiteren Abschnitten dieses Tutorials.

Das Programm soll auf einem AVR Mikrocontroller einige Ausgänge ein- und andere ausschalten. Das Beispiel ist für einen ATmega16 programmiert ([http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf Datenblatt]), kann aber sinngemäß für andere Controller der AVR-Familie modifiziert werden.

Ein kurzes Wort zur Hardware: Bei diesem Programm werden alle Pins von PORTB auf Ausgang gesetzt, und einige davon werden auf HIGH andere auf LOW gesetzt. Das kann je nach angeschlossener Hardware an diesen Pins kritisch sein. Am ungefährlichsten ist es, wenn nichts an den Pins angeschlossen ist und man die Funktion des Programmes durch eine Spannungsmessung mit einem Multimeter kontrolliert. Die Spannung wird dabei zwischen GND-Pin und den einzelnen Pins von PORTB gemessen.

Zunächst der Quellcode der Anwendung, der in einer Text-Datei mit dem Namen ''main.c'' abgespeichert wird.

<c>
/* Alle Zeichen zwischen Schrägstrich-Stern
und Stern-Schrägstrich sind Kommentare */

// Zeilenkommentare sind ebenfalls möglich
// alle auf die beiden Schrägstriche folgenden
// Zeichen einer Zeile sind Kommentar

#include <avr/io.h> // (1)

int main (void) { // (2)

DDRB = 0xFF; // (3)
PORTB = 0x03; // (4)

while(1) { // (5)
/* "leere" Schleife*/ // (6)
} // (7)

/* wird nie erreicht */
return 0; // (8)
}
</c>

# In dieser Zeile wird eine sogenannte Header-Datei eingebunden. In <code>avr/io.h</code> sind die Registernamen definiert, die im späteren Verlauf genutzt werden. Auch unter Windows wird ein <code>/</code> zur Kennzeichnung von Unterverzeichnissen in Include-Dateinamen verwendet und kein <code>\</code>.
# Hier beginnt das eigentliche Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion <code>main</code>.
# Die Anschlüsse eines AVR ("Beinchen") werden zu Blöcken zusammengefasst, einen solchen Block bezeichnet man als Port. Beim ATmega16 hat jeder Port 8 Anschlüsse, bei kleineren AVRs können einem Port auch weniger als 8 Anschlüsse zugeordnet sein. Da per Definition (Datenblatt) alle gesetzten Bits in einem Datenrichtungsregister den entsprechenden Anschluss auf Ausgang schalten, werden mit DDRB=0xff alle Anschlüsse des Ports B als Ausgänge eingestellt.
# stellt die Werte der Ausgänge ein. Die den ersten beiden Bits des Ports zugeordneten Anschlüsse (PB0 und PB1) werden 1, alle anderen Anschlüsse des Ports B (PB2-PB7) zu 0. Aktivierte Ausgänge (logisch 1 oder "high") liegen auf Betriebsspannung (VCC, meist 5 Volt), nicht aktivierte Ausgänge führen 0 Volt (GND, Bezugspotential). Es ist sinnvoll, sich möglichst frühzeitig eine alternative Schreibweise beizubringen, die wegen der leichteren Überprüfbarkeit und Portierbarkeit oft im weiteren Tutorial und in Forenbeiträgen benutzt wird. Die Zuordnung sieht in diesem Fall so aus, Näheres dazu im Artikel [[Bitmanipulation]]:<c>PORTB = (1<<PB1) | (1<<PB0);</c>
# ist der Beginn der sogenannte ''Hauptschleife'' (main-loop). Dies ist eine Endlosschleife, welche kontinuierlich wiederkehrende Befehle enthält.
# In diesem Beispiel ist die Hauptschleife leer. Der Controller durchläuft die Schleife immer wieder, ohne dass etwas passiert. Eine solche Schleife ist notwendig, da es auf dem Controller kein Betriebssystem gibt, das nach Beendigung des Programmes die Kontrolle übernehmen könnte. Ohne diese Schleife kehrt das Programm aus <code>main</code> zurück, alle Interrupts werden deaktiviert und eine Endlosschleife betreten.
# Ende der Hauptschleife und Sprung zur passenden, öffnenden Klammer, also zu 5.
# ist das Programmende. Die Zeile ist nur aus Gründen der C-Kompatibilität enthalten: <c>int main(void)</c> besagt, dass die Funktion einen int-Wert zurückgibt. Die Anweisung wird aber nicht erreicht, da das Programm die Hauptschleife nie verlässt.

Um diesen Quellcode in ein lauffähiges Programm zu übersetzen, wird hier ein Makefile genutzt. Das verwendete Makefile findet sich auf der Seite [[Beispiel Makefile]] und basiert auf der Vorlage, die in WinAVR mitgeliefert wird und wurde bereits angepasst (Controllertyp ATmega16). Man kann das Makefile bearbeiten und an andere Controller anpassen oder sich mit dem Programm MFile menügesteuert ein Makefile "zusammenklicken". Das Makefile speichert man unter dem Namen <code>Makefile</code> (ohne Endung) im selben Verzeichnis, in dem auch die Datei <code>main.c</code> mit dem Programmcode abgelegt ist. Detailliertere Erklärungen zur Funktion von Makefiles finden sich im Artikel [[AVR-GCC-Tutorial/Exkurs_Makefiles|Exkurs: Makefiles]].

<pre>
D:\beispiel>dir

Verzeichnis von D:\beispiel

28.11.2006 22:53 <DIR> .
28.11.2006 22:53 <DIR> ..
28.11.2006 20:06 118 main.c
28.11.2006 20:03 16.810 Makefile
2 Datei(en) 16.928 Bytes
</pre>

Nun gibt man ''make all'' ein. Falls das mit WinAVR installierte Programmers Notepad genutzt wird, gibt es dazu einen Menüpunkt im Tools Menü. Sind alle Einstellungen korrekt, entsteht eine Datei <code>main.hex</code>, in welcher der Code für den AVR enthalten ist.
<pre>
D:\beispiel>make all

-------- begin --------
avr-gcc (GCC) 3.4.6
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Compiling C: main.c
avr-gcc -c -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -f
unsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef
-Wa,-adhlns=obj/main.lst -std=gnu99 -Wundef -MD -MP -MF .dep/main.o.d main.c -
o obj/main.o

Linking: main.elf
avr-gcc -mmcu=atmega16 -I. -gdwarf-2 -DF_CPU=1000000UL -Os -funsigned-char -funs
igned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wundef -W
a,-adhlns=obj/main.o -std=gnu99 -Wundef -MD -MP -MF .dep/main.elf.d obj/main.o
--output main.elf -Wl,-Map=main.map,--cref -lm

Creating load file for Flash: main.hex
avr-objcopy -O ihex -R .eeprom main.elf main.hex
</pre>

Der Inhalt der hex-Datei kann nun zum Controller übertragen werden. Dies kann z. B. über In-System-Programming ([[ISP]]) erfolgen, das im [[AVR-Tutorial: Equipment]] beschrieben ist. Makefiles nach der WinAVR/MFile-Vorlage sind für die Nutzung des Programms [[AVRDUDE]] vorbereitet. Wenn man den Typ und Anschluss des Programmiergerätes richtig eingestellt hat, kann mit ''make program'' die Übertragung mittels AVRDUDE gestartet werden. Jede andere Software, die hex-Dateien lesen und zu einem AVR übertragen kann<ref>z. B. [[Pony-Prog_Tutorial|Ponyprog]], yapp, AVRStudio</ref>, kann natürlich ebenfalls genutzt werden.

Startet man nun den Controller (Reset-Taster oder Stromzufuhr aus/an), werden vom Programm die Anschlüsse PB0 und PB1 auf 1 gesetzt. Man kann mit einem Messgerät nun an diesem Anschluss die Betriebsspannung messen oder eine [[LED]] leuchten lassen (Anode an den Pin, Vorwiderstand nicht vergessen). An den Anschlüssen PB2-PB7 misst man 0 Volt. Eine mit der Anode mit einem dieser Anschlüsse verbundene LED leuchtet nicht.

= Ganzzahlige (Integer) Datentypen =

Bei der Programmierung von Mikrokontrollern ist die Definition einiger ganzzahliger Datentypen sinnvoll, an denen eindeutig die Bit-Länge abgelesen werden kann.

Standardisierte Datentypen werden in der Header-Datei <code>stdint.h</code> definiert, die folgendermaßen eingebunden werden kann:
<c>#include <stdint.h></c>

{| {{Tabelle}}
|+ '''int-Typen aus <code>stdint.h</code> (C99)'''  
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenbehaftete int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>int8_t</code> ||align="right"| 8 || −128 ⋯ 127 || −27 ⋯ 27−1 || <code>signed char</code>
|-
|<code>int16_t</code> ||align="right"| 16 || −32768 ⋯ 32767 || −215 ⋯ 215−1 || <code>signed short</code>, <code>signed int</code>
|-
|<code>int32_t</code> ||align="right"| 32 || −2147483648 ⋯ 2147483647 || −231 ⋯ 231−1 || <code>signed long</code>
|-
|<code>int64_t</code> ||align="right"| 64 || −9223372036854775808 ⋯ 9223372036854775807 || −263 ⋯ 263−1 || <code>signed long long</code>
|- bgcolor="#d0d0ff"
!colspan="5"| Vorzeichenlose int-Typen
|- bgcolor="#e8e8ff"
! Typname || Bit-Breite ||colspan="2"| Wertebereich
|align="center| '''C-Entsprechung''' (avr-gcc)
|-
|<code>uint8_t</code> ||align="right"| 8 || 0 ⋯ 255 || 0 ⋯ 28−1 || <code>unsigned char</code>
|-
|<code>uint16_t</code> ||align="right"| 16 || 0 ⋯ 65535 || 0 ⋯ 216−1 || <code>unsigned short</code>, <code>unsigned int</code>
|-
|<code>uint32_t</code> ||align="right"| 32 || 0 ⋯ 4294967295 || 0 ⋯ 232−1 || <code>unsigned long</code>
|-
|<code>uint64_t</code> ||align="right"| 64 || 0 ⋯ 18446744073709551615 || 0 ⋯ 264−1 || <code>unsigned long long</code>
|}

Neben den Typen gibt es auch Makros für die Bereichsgrenzen wie <code>INT8_MIN</code> oder <code>UINT16_MAX</code>. Siehe dazu auch: [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdint.html Dokumentation der avr-libc: Standard Integer Types].

= Bitfelder =

Beim Programmieren von Mikrocontrollern muss auf jedes Byte oder sogar auf
jedes Bit geachtet werden. Oft müssen wir in einer Variablen lediglich den
Zustand 0 oder 1 speichern. Wenn wir nun zur Speicherung eines einzelnen Wertes
den kleinsten bekannten Datentypen, nämlich '''unsigned char''', nehmen, dann
verschwenden wir 7 Bits, da ein '''unsigned char''' ja 8 Bits breit ist.

Hier bietet uns die Programmiersprache C ein mächtiges Werkzeug an, mit dessen
Hilfe wir 8 Bits in eine einzelne Bytevariable zusammenfassen und (fast) wie
8 einzelne Variablen ansprechen können. Die Rede ist von sogenannten Bitfeldern. Diese werden als Strukturelemente definiert. Sehen wir uns dazu doch am besten gleich ein Beispiel an:

<c>
struct {
unsigned bStatus_1:1; // 1 Bit für bStatus_1
unsigned bStatus_2:1; // 1 Bit für bStatus_2
unsigned bNochNBit:1; // Und hier noch mal ein Bit
unsigned b2Bits:2; // Dieses Feld ist 2 Bits breit
// All das hat in einer einzigen Byte-Variable Platz.
// die 3 verbleibenden Bits bleiben ungenutzt
} x;
</c>

Der Zugriff auf ein solches Feld erfolgt nun, wie beim Strukturzugriff bekannt,
über den Punkt- oder den Dereferenzierungs-Operator:

<c>
x.bStatus_1 = 1;
x.bStatus_2 = 0;
x.b2Bits = 3;
</c>

Bitfelder sparen Platz im RAM, zu Lasten von Platz im Flash, verschlechtern aber unter Umständen die Les- und Wartbarkeit des Codes. Anfängern wird deshalb geraten, ein "ganzes" Byte (uint8_t) zu nutzen, auch wenn nur ein Bitwert gespeichert werden soll.

= Grundsätzlicher Programmaufbau eines µC-Programms =

Wir unterscheiden zwischen 2 verschiedenen Methoden, um ein
Mikrocontroller-Programm zu schreiben, und zwar völlig unabhängig davon, in
welcher Programmiersprache das Programm geschrieben wird.

== Sequentieller Programmablauf ==

[[Image:Sequentielle Programme.gif|left]]
Bei dieser Programmiertechnik wird eine Endlosschleife programmiert, welche im
Wesentlichen immer den gleichen Aufbau hat. Es wird hier nach dem sogenannten EVA-Prinzip gehandelt. EVA steht für "Eingabe, Verarbeitung, Ausgabe":
{{Absatz}}

== Interruptgesteuerter Programmablauf ==

[[Image:Interrupt Programme.gif|left]]
Bei dieser Methode werden beim Programmstart zuerst die gewünschten Interruptquellen aktiviert und dann in eine Endlosschleife gegangen, in welcher Dinge erledigt werden können, welche nicht zeitkritisch sind. Wenn ein Interrupt ausgelöst wird, so wird automatisch die zugeordnete Interruptfunktion ausgeführt.
{{Absatz}}

= Zugriff auf Register =

Die AVR-Controller verfügen über eine Vielzahl von Registern. Die meisten
davon sind sogenannte Schreib-/Leseregister. Das heißt, das Programm kann die
Inhalte der Register sowohl auslesen als auch beschreiben.

Register haben einen besonderen Stellenwert bei den AVR Controllern. Sie dienen dem Zugriff auf die Ports und die Schnittstellen des Controllers. Wir unterscheiden zwischen 8-Bit und 16-Bit Registern. Vorerst behandeln wir die 8-Bit Register.

Einzelne Register sind bei allen AVRs vorhanden, andere wiederum nur bei bestimmten Typen. So sind beispielsweise die Register, welche für den Zugriff auf den UART notwendig sind, selbstverständlich nur bei denjenigen Modellen vorhanden, welche über einen integrierten Hardware UART bzw. USART verfügen.

Die Namen der Register sind in den Headerdateien zu den entsprechenden AVR-Typen definiert. Dazu muss man den Namen der controllerspezifischen Headerdatei nicht kennen. Es reicht aus, die allgemeine Headerdatei ''avr/io.h'' einzubinden:

<c>
#include <avr/io.h>
</c>

Ist im Makefile der MCU-Typ z. B. mit dem Inhalt atmega8 definiert (und wird somit per -mmcu=atmega8 an den Compiler übergeben), wird beim Einlesen der io.h-Datei implizit ("automatisch") auch die iom8.h-Datei mit den Register-Definitionen für den ATmega8 eingelesen.


Intern wird diese "Automatik" wie folgt realisiert: Der Controllertyp wird dem Compiler als Parameter übergeben (vgl. ''avr-gcc -c -mmcu=atmega16 [...]'' im Einführungsbeispiel). Wird ein Makefile nach der WinAVR/mfile-Vorlage verwendet, setzt man die Variable ''MCU'', der Inhalt dieser Variable wird dann an passender Stelle für die Compilerparameter verwendet. Der Compiler definiert intern eine dem mmcu-Parameter zugeordnete "Variable" (genauer: ein Makro) mit dem Namen des Controllers, vorangestelltem ''__AVR_'' und angehängten Unterstrichen (z. B. wird bei ''-mmcu=atmega16'' das Makro ''__AVR_ATmega16__'' definiert). Beim Einbinden der Header-Datei ''avr/io.h'' wird geprüft, ob das jeweilige Makro definiert ist und die zum Controller passende Definitionsdatei eingelesen. Zur Veranschaulichung einige Ausschnitte aus einem Makefile:

<pre>
[...]
# MCU Type ("name") setzen:
MCU = atmega16
[...]

[...]
## Verwendung des Inhalts von MCU (hier atmega16) fuer die
## Compiler- und Assembler-Parameter
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
[...]

[...]
## Aufruf des Compilers:
## mit den Parametern ($(ALL_CFLAGS) ist -mmcu=$(MCU)[...] = -mmcu=atmega16[...]
$(OBJDIR)/%.o : %.c
@echo
@echo $(MSG_COMPILING) $<
$(CC) -c $(ALL_CFLAGS) $< -o $@
[...]
</pre>

Da --mmcu=atmega16 übergeben wurde, wird __AVR_ATmega16__ definiert und kann in avr/io.h zur Fallunterscheidung genutzt werden:

<c>
// avr/io.h
// (bei WinAVR-Standardinstallation in C:\WinAVR\avr\include\avr)
[...]
#if defined (__AVR_AT94K__)
# include <avr/ioat94k.h>
// [...]
#elif defined (__AVR_ATmega16__)
// da __AVR_ATmega16__ definiert ist, wird avr/iom16.h eingebunden:
# include <avr/iom16.h>
// [...]
#else
# if !defined(__COMPILING_AVR_LIBC__)
# warning "device type not defined"
# endif
#endif
</c>

Die Beispiele in den folgenden Abschnitten demonstrieren den Zugriff auf Register anhand der Register für I/O-Ports (PORTx, DDRx, PINx), die Vorgehensweise ist jedoch für alle Register (z. B. die des UART, ADC, SPI) analog.

== Schreiben in Register ==

Zum Schreiben kann man Register einfach wie eine Variable setzen.<ref>In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Schreibzugriff über die Funktion outp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt, outp() ist nicht mehr erforderlich.</ref>

Beispiel:

<c>
#include <avr/io.h>

int main()
{
/* Setzt das Richtungsregister des Ports A auf 0xff
(alle Pins als Ausgang, vgl. Abschnitt Zugriff auf Ports): */
DDRA = 0xff;

/* Setzt PortA auf 0x03, Bit 0 und 1 "high", restliche "low": */
PORTA = 0x03;

// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
DDRB = 0x1F; /* direkte Zuweisung - unübersichtlich */

/* Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
aber übersichtlicher und selbsterklärend: */
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);

while (1);
}
</c>

Die ausführliche Schreibweise sollte bevorzugt verwendet werden, da dadurch die Zuweisungen selbsterklärend sind und somit der Code leichter nachvollzogen werden kann. Atmel verwendet sie auch bei Beispielen in Datenblätten und in den allermeisten Quellcodes zu Application-Notes. Mehr zu der Schreibweise mit "|" und "<<" findet man unter [[Bitmanipulation]].

Der gcc C-Compiler unterstützt ab Version 4.3.0 Konstanten im Binärformat, z. B. DDRB = 0b00011111. Diese Schreibweise ist jedoch nur in GNU-C verfügbar und nicht in ISO-C definiert. Man sollte sie daher nicht verwenden, wenn Code mit anderen ausgetauscht oder mit anderen Compilern bzw. älteren Versionen des gcc genutzt werden soll.

== Verändern von Registerinhalten ==

Einzelne Bits setzt und löscht man "Standard-C-konform" mittels logischer (Bit-) Operationen.

<c>
x |= (1 << Bitnummer); // Hiermit wird ein Bit in x gesetzt
x &= ~(1 << Bitnummer); // Hiermit wird ein Bit in x geloescht
</c>

Es wird jeweils nur der Zustand des angegebenen Bits geändert, der vorherige Zustand der anderen Bits bleibt erhalten.

Beispiel:
<c>
#include <avr/io.h>
...
#define MEINBIT 2
...
PORTA |= (1 << MEINBIT); /* setzt Bit 2 an PortA auf 1 */
PORTA &= ~(1 << MEINBIT); /* loescht Bit 2 an PortA */
</c>

Mit dieser Methode lassen sich auch mehrere Bits eines Registers gleichzeitig setzen und löschen.

Beispiel:
<c>
#include <avr/io.h>
...
DDRA &= ~( (1<<PA0) | (1<<PA3) ); /* PA0 und PA3 als Eingaenge */
PORTA |= (1<<PA0) | (1<<PA3); /* Interne Pull-Up fuer beide einschalten */
</c>

Bei bestimmten AVR Registern mit Bits, die durch Beschreiben mit einer logischen 1 gelöscht werden, muss eine absolute Zuweisung benutzt werden. Ein ODER löscht in diesen Registern ALLE gesetzten Bits!

Beispiel:
<c>
#include <avr/io.h>
...
TIFR2 = (1<<OCF2A); // Nur Bit OCF2A löschen
</c>

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind nicht mehr erforderlich.

Siehe auch:
* [[Bitmanipulation]]
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers

== Lesen aus Registern ==

Zum Lesen kann man auf Register einfach wie auf eine Variable zugreifen. In Quellcodes, die für ältere Versionen des avr-gcc/der avr-libc entwickelt wurden, erfolgt der Lesezugriff über die Funktion inp(). Aktuelle Versionen des Compilers unterstützen den Zugriff nun direkt und inp() ist nicht mehr erforderlich.

Beispiel:

<c>
#include <avr/io.h>
#include <stdint.h>

uint8_t foo;

//...

int main(void)
{
/* kopiert den Status der Eingabepins an PortB
in die Variable foo: */
foo = PINB;
//...
}
</c>

Die Abfrage der Zustände von Bits erfolgt durch Einlesen des gesamten Registerinhalts und ausblenden der Bits deren Zustand nicht von Interesse ist. Einige Beispiele zum Prüfen ob Bits gesetzt oder gelöscht sind:

<c>
#define MEINBIT0 0
#define MEINBIT2 2

uint8_t i;

extern test1();

// Funkion test1 aufrufen, wenn Bit 0 in Register PINA gesetzt (1) ist
i = PINA; // Inhalt in Arbeitsvariable
i = i & 0x01; // alle Bits bis auf Bit 0 ausblenden (bitweise und)
// falls das Bit gesetzt war, hat i den Inhalt 1
if ( i != 0 ) { // Ergebnis ungleich 0 (wahr)?
test1(); // dann muss Bit 0 in i gesetzt sein -> Funktion aufrufen
}
// verkürzt:
if ( ( PINA & 0x01 ) != 0 ) {
test1();
}
// nochmals verkürzt:
if ( PINA & 0x01 ) {
test1();
}
// mit definierter Bitnummer:
if ( PINA & ( 1 << MEINBIT0 ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 und/oder Bit 2 gesetzt ist. (Bit 0 und 2 also Wert 5)
// (Bedenke: Bit 0 hat Wert 1, Bit 1 hat Wert 2 und Bit 2 hat Wert 4)
if ( PINA & 0x05 ) {
test1(); // Vergleich <> 0 (wahr), also mindestens eines der Bits gesetzt
}
// mit definierten Bitnummern:
if ( PINA & ( ( 1 << MEINBIT0 ) | ( 1 << MEINBIT2 ) ) ) {
test1();
}

// Funktion aufrufen, wenn Bit 0 und Bit 2 gesetzt sind
if ( ( PINA & 0x05 ) == 0x05 ) { // nur wahr, wenn beide Bits gesetzt
test1();
}

// Funktion test2() aufrufen, wenn Bit 0 gelöscht (0) ist
i = PINA; // einlesen in temporäre Variable
i = i & 0x01; // maskieren von Bit 0
if ( i == 0 ) { // Vergleich ist wahr, wenn Bit 0 nicht gesetzt ist
test2();
}
// analog mit not-Operator
if ( !i ) {
test2();
}
// nochmals verkürzt:
if ( !( PINA & 0x01 ) ) {
test2();
}
</c>

== Warten auf einen bestimmten Zustand ==

Es gibt in der Bibliothek avr-libc Funktionen, die warten, bis ein bestimmter Zustand eines Bits erreicht ist. Es ist allerdings normalerweise eine eher unschöne Programmiertechnik, da in diesen Funktionen "blockierend" gewartet wird. Der Programmablauf bleibt also an dieser Stelle stehen, bis das maskierte Ereignis erfolgt ist. Setzt man den [[Watchdog]] ein, muss man darauf achten, dass dieser auch noch getriggert wird (Zurücksetzen des Watchdogtimers).

Die Funktion '''loop_until_bit_is_set''' wartet in einer Schleife, bis das definierte Bit gesetzt ist. Wenn das Bit beim Aufruf der Funktion bereits gesetzt ist, wird die Funktion sofort wieder verlassen. Das niederwertigste Bit hat die Bitnummer 0.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 2 (das dritte Bit) in Register PINA gesetzt (1) ist */

#define WARTEPIN PINA
#define WARTEBIT PA2

// mit der avr-libc Funktion:
loop_until_bit_is_set(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// _nicht_ ungleich 0 (also 0) ist.
while ( !(WARTEPIN & (1 << WARTEBIT)) ) {}
...
</c>

Die Funktion '''loop_until_bit_is_clear''' wartet in einer Schleife, bis das definierte Bit gelöscht ist. Wenn das Bit beim Aufruf der Funktion bereits gelöscht ist, wird die Funktion sofort wieder verlassen.

<c>
#include <avr/io.h>
...

/* Warten bis Bit Nr. 4 (das fuenfte Bit) in Register PINB geloescht (0) ist */
#define WARTEPIN PINB
#define WARTEBIT PB4

// avr-libc-Funktion:
loop_until_bit_is_clear(WARTEPIN, WARTEBIT);

// dito in "C-Standard":
// Durchlaufe die (leere) Schleife solange das WARTEBIT in Register WARTEPIN
// gesetzt (1) ist
while ( WARTEPIN & (1<<WARTEBIT) ) {}
...
</c>

Universeller und auch auf andere Plattformen besser übertragbar ist die Verwendung von C-Standardoperationen.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Special Function Registers
* [[Bitmanipulation]]

== 16-Bit Register (ADC, ICR1, OCR1x, TCNT1, UBRR) ==

Einige der Portregister in den AVR-Controllern sind 16 Bit breit. Im Datenblatt sind diese Register üblicherweise mit dem Suffix "L" (Low-Byte) und "H" (High-Byte) versehen. Die avr-libc definiert zusätzlich die meisten dieser Variablen die Bezeichnung ohne "L" oder "H". Auf diese Register kann dann direkt zugegriffen werden. Dies ist zum Beispiel der Fall für Register wie ADC oder TCNT1.
<c>
#include <avr/io.h>
...
uint16_t foo;

/* setzt die Wort-Variable foo auf den Wert der letzten AD-Wandlung */
foo = ADC;
</c>

Bei anderen Registern, wie zum Beispiel Baudraten-Register, liegen High- und Low-Teil nicht direkt nebeneinander im SFR-Bereich, so dass ein 16-Bit Zugriff nicht möglich ist und der Zugriff zusammengebastelt werden muss:

<c>
#include <avr/io.h>

#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

...
uint16_t baud = F_CPU / (UART_BAUD_RATE * 16L) -1;

UBRRH = (uint8_t) (baud >> 8);
UBRRL = (uint8_t) baud;
...
</c>

Bei einigen AVR-Typen wie ATmega8 oder ATmega16 teilen sich UBRRH und UCSRC die gleiche Speicher-Adresse. Damit der AVR trotzdem zwischen den beiden Registern unterscheiden kann, bestimmt das Bit7 (URSEL), welches Register tatsächlich beschrieben werden soll. ''1000 0011'' (0x83) adressiert demnach UCSRC und übergibt den Wert ''3'' und ''0000 0011'' (0x3) adressiert UBRRH und übergibt ebenfalls den Wert ''3''.

Speziell bei den 16-Bit-Timern und auch beim ADC ist es bei allen Zugriffen auf Datenregister erforderlich, dass diese Daten synchronisiert sind. Wenn z. B. bei einem 16-Bit-Timer das High-Byte des Zählregisters gelesen wurde und vor dem Lesezugriff auf das Low-Byte ein Überlauf des Low-Bytes stattfindet, erhält man einen völlig unsinnigen Wert. Auch die Compare-Register müssen synchron geschrieben werden, da es ansonsten zu unerwünschten Compare-Ereignissen kommen kann.

Beim ADC besteht das Problem darin, dass zwischen den Zugriffen auf die beiden Teilregister eine Wandlung beendet werden kann und der ADC ein neues Ergebnis in ADCL und ADCH schreiben will, wodurch High- und Low-Byte nicht zusammenpassen.

Um diese Datenmüllproduktion zu verhindern, gibt es in beiden Fällen eine Synchronisation, die jeweils durch den Zugriff auf das Low-Byte ausgelöst wird:
* Bei den Timer-Registern (das gilt für alle TCNT-, OCR- und ICR-Register bei den 16-Bit-Timern) wird bei einem ''Lesezugriff'' auf das Low-Byte automatisch das High-Byte in ein temporäres Register, das ansonsten nach außen nicht sichtbar ist, geschoben. Greift man nun ''anschließend'' auf das High-Byte zu, dann wird eben dieses temporäre Register gelesen.
* Bei einem ''Schreibzugriff'' auf eines der genannten Register wird das High-Byte in besagtem temporären Register zwischengespeichert und erst beim Schreiben des Low-Bytes werden ''beide'' gleichzeitig in das eigentliche Register übernommen.

Das bedeutet für die Reihenfolge:
* Lesezugriff: Erst Low-Byte, dann High-Byte
* Schreibzugriff: Erst High-Byte, dann Low-Byte

Des weiteren ist zu beachten, dass es für all diese 16-Bit-Register nur ein einziges temporäres Register gibt, so dass das Auftreten eines Interrupts, in dessen Handler ein solches Register manipuliert wird, bei einem durch ihn unterbrochenen Zugriff i.d.R. zu Datenmüll führt. 16-Bit-Zugriffe sind generell nicht atomar! Wenn mit Interrupts gearbeitet wird, kann es erforderlich sein, vor einem solchen Zugriff auf ein 16-Bit-Register die Interrupt-Bearbeitung zu deaktivieren.

Beim ADC-Datenregister ADCH/ADCL ist die Synchronisierung anders gelöst. Hier wird beim Lesezugriff (ADCH/ADCL sind logischerweise read-only) auf das Low-Byte ADCL beide Teilregister für Zugriffe seitens des ADC so lange gesperrt, bis das High-Byte ADCH ausgelesen wurde. Dadurch kann der ADC nach einem Zugriff auf ADCL keinen neuen Wert in ADCH/ADCL ablegen, bis ADCH gelesen wurde. Ergebnisse von Wandlungen, die zwischen einem Zugriff auf ADCL und ADCH beendet werden, gehen verloren!

Nach einem Zugriff auf ADCL muss grundsätzlich ADCH gelesen werden!

In beiden Fällen – also sowohl bei den Timern als auch beim ADC – werden vom C-Compiler 16-Bit Pseudo-Register zur Verfügung gestellt (z. B. TCNT1H/TCNT1L → TCNT1, ADCH/ADCL → ADC bzw. ADCW), bei deren Verwendung der Compiler automatisch die richtige Zugriffsreihenfolge regelt. In C-Programmen sollten grundsätzlich diese 16-Bit-Register verwendet werden! Sollte trotzdem ein Zugriff auf ein Teilregister erforderlich sein, sind obige Angaben zu berücksichtigen.

Es ist darauf zu achten, dass auch ein Zugriff auf die 16-Bit-Register vom Compiler in zwei 8-Bit-Zugriffe aufgeteilt wird und dementsprechend genauso nicht-atomar ist wie die Einzelzugriffe. Auch hier gilt, dass u.U. die Interrupt-Bearbeitung gesperrt werden muss, um Datenmüll zu vermeiden.

Beim ADC gibt es für den Fall, dass eine Auflösung von 8 Bit ausreicht, die Möglichkeit, das Ergebnis "linksbündig" in ADCH/ADCL auszurichten, so dass die relevanten 8 MSB in ADCH stehen. In diesem Fall muss bzw. sollte nur ADCH ausgelesen werden.

ADC und ADCW sind unterschiedliche Bezeichner für das selbe Registerpaar. Üblicherweise kann man in C-Programmen ADC verwenden, was analog zu den anderen 16-Bit-Registern benannt ist. ADCW (ADC Word) existiert nur deshalb, weil die Headerdateien auch für Assembler vorgesehen sind und es bereits einen Assembler-Befehl namens ''adc'' gibt.

Im Umgang mit 16-Bit Registern siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Related Pages/Frequently Asked Questions/Nr. 8
* Datenblatt Abschnitt ''Accessing 16-bit Registers''

== IO-Register als Parameter und Variablen ==

Um Register als Parameter für eigene Funktionen übergeben zu können, muss man sie als einen volatile uint8_t Pointer übergeben. Zum Beispiel:

<c>
#include <avr/io.h>
#include <util/delay.h>

uint8_t key_pressed (volatile uint8_t *inputreg, uint8_t inputbit)
{
static uint8_t last_state = 0;

if (last_state == (*inputreg & (1<<inputbit)))
return 0; /* keine Änderung */

/* Wenn doch, warten bis etwaiges Prellen vorbei ist: */
_delay_ms(20);

/* Zustand für nächsten Aufruf merken: */
last_state = *inputreg & (1<<inputbit);

/* und den entprellten Tastendruck zurückgeben: */
return *inputreg & (1<<inputbit);
}

/* Beispiel für einen Funktionsaufruf: */

void foo (void)
{
uint8_t i = key_pressed (&PINB, PB1);
}
</c>

Ein Aufruf der Funktion mit call by value würde Folgendes bewirken: Beim Funktionseintritt wird nur eine Kopie des momentanen Portzustandes angefertigt, die sich unabhängig vom tatsächlichen Zustand das Ports nicht mehr ändert, womit die Funktion wirkungslos wäre. Die Übergabe eines Zeigers wäre die Lösung, wenn der Compiler nicht optimieren würde. Denn dadurch wird im Programm nicht von der Hardware gelesen, sondern wieder nur von einem Abbild im Speicher. Das Ergebnis wäre das gleiche wie oben. Mit dem Schlüsselwort volatile sagt man nun dem Compiler, dass die entsprechende Variable entweder durch andere Softwareroutinen (Interrupts) oder durch die Hardware verändert werden kann.

Siehe auch: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass avr-libc FAQ: "How do I pass an IO port as a parameter to a function?"]

= Zugriff auf IO-Ports =

Jeder AVR implementiert eine unterschiedliche Menge an GPIO-Registern
(GPIO - General Purpose Input/Output). Diese Register dienen dazu:
* einzustellen welche der Anschlüsse ("Beinchen") des Controllers als Ein- oder Ausgänge dienen
* bei Ausgängen deren Zustand festzulegen
* bei Eingängen deren Zustand zu erfassen

Mittels GPIO werden digitale Zustände gesetzt und erfasst, d.h. die Spannung an einem Ausgang wird ein- oder ausgeschaltet und an einem Eingang wird erfasst, ob die anliegende Spannung über oder unter einem bestimmten Schwellwert liegt. Im Datenblatt Abschnitt Electrical Characteristics/DC Characteristics finden sich die Spannungswerte (V_OL, V_OH für Ausgänge, V_IL, V_IH für Eingänge).

Die Verarbeitung von analogen Eingangswerten und die Ausgabe von Analogwerten wird in Kapitel [[AVR-GCC-Tutorial#Analoge_Ein-_und_Ausgabe|Analoge Ein- und Ausgabe]] behandelt.

Die physischen Ein- und Ausgänge werden bei AVR-Controllern zu logischen Ports gruppiert.

Alle Ports werden über Register gesteuert. Dazu sind jedem Port 3 Register zugeordnet:

{| class="wikitable"
|-
! DDRx
| Datenrichtungsregister für Port'''x'''.
'''x''' entspricht '''A''', '''B''', ''' C''', '''D''' usw. (abhängig von der Anzahl der Ports des verwendeten AVR). Bit im Register gesetzt (1) für Ausgang, Bit gelöscht (0) für Eingang.
|-
! PINx
| Eingangsadresse für Port'''x'''.
Zustand des Ports. Die Bits in PINx entsprechen dem Zustand der als Eingang definierten Portpins. Bit 1 wenn Pin "high", Bit 0 wenn Portpin low.
|-
! PORTx
| Datenregister für Port'''x'''.
Dieses Register wird verwendet, um die Ausgänge eines Ports anzusteuern. Bei Pins, die mittels DDRx auf Eingang geschaltet wurden, können über PORTx
die internen Pull-Up Widerstände aktiviert oder deaktiviert werden (1 = aktiv).
|}

Die folgenden Beispiele gehen von einem AVR aus, der sowohl Port A als auch Port B besitzt. Sie müssen für andere AVRs (zum Beispiel ATmega8/48/88/168) entsprechend angepasst werden.

== Datenrichtung bestimmen ==

Zuerst muss die Datenrichtung der verwendeten Pins bestimmt werden. Um dies zu erreichen, wird das Datenrichtungsregister des entsprechenden Ports beschrieben.

Für jeden Pin, der als Ausgang verwendet werden soll, muss dabei das
entsprechende Bit auf dem Port gesetzt werden. Soll der Pin als Eingang
verwendet werden, muss das entsprechende Bit gelöscht sein.

Beispiel:
Angenommen am Port B sollen die Pins 0 bis 4 als Ausgänge definiert werden, die noch verbleibenden Pins 5 bis 7 sollen als Eingänge fungieren. Dazu ist es daher notwendig, im für das Port B zuständigen Datenrichtungsregister DDRB folgende Bitkonfiguration einzutragen

+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+
7 6 5 4 3 2 1 0

In C liest sich das dann so:

<c>
// in io.h wird u.a. DDRB definiert:
#include <avr/io.h>

int main()
{
// Setzen der Bits 0,1,2,3 und 4
// Binär 00011111 = Hexadezimal 1F
// direkte Zuweisung - standardkonform */
DDRB = 0x1F; /*

// übersichtliche Alternative - Binärschreibweise, aber kein ISO-C
DDRB = 0b00011111;

// Ausführliche Schreibweise: identische Funktionalität, mehr Tipparbeit
// aber übersichtlicher und selbsterklärend:
DDRB = (1 << DDB0) | (1 << DDB1) | (1 << DDB2) | (1 << DDB3) | (1 << DDB4);
</c>

Die Pins 5 bis 7 werden (da 0) als Eingänge geschaltet. Weitere Beispiele:

<c>
// Alle Pins des Ports B als Ausgang definieren:
DDRB = 0xff;
// Pin0 wieder auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~(1 << DDB0);
// Pin 3 und 4 auf Eingang und andere im ursprünglichen Zustand belassen:
DDRB &= ~((1 << DDB3) | (1 << DDB4));
// Pin 0 und 3 wieder auf Ausgang und andere im ursprünglichen Zustand belassen:
DDRB |= (1 << DDB0) | (1 << DDB3);
// Alle Pins auf Eingang:
DDRB = 0x00;
</c>

== Vordefinierte Bitnummern für I/O-Register ==

Die Bitnummern (z. B. PCx, PINCx und DDCx für den Port C) sind in den io*.h-Dateien der avr-libc definiert und dienen lediglich der besseren Lesbarkeit. Man muss diese Definitionen nicht verwenden oder kann auch einfach "immer" PAx, PBx, PCx usw. nutzen, auch wenn der Zugriff auf Bits in DDRx- oder PINx-Registern erfolgt. Für den Compiler sind die Ausdrücke (1<<PC7), (1<<DDC7) und (1<<PINC7) identisch zu (1<<7) (genauer: der Präprozessor ersetzt die Ausdrücke (1<<PC7),... zu (1<<7)). Ein Ausschnitt der Definitionen für Port C eines ATmega32 aus der iom32.h-Datei zur Verdeutlichung (analog für die weiteren Ports):

<c>
...
/* PORTC */
#define PC7 7
#define PC6 6
#define PC5 5
#define PC4 4
#define PC3 3
#define PC2 2
#define PC1 1
#define PC0 0

/* DDRC */
#define DDC7 7
#define DDC6 6
#define DDC5 5
#define DDC4 4
#define DDC3 3
#define DDC2 2
#define DDC1 1
#define DDC0 0

/* PINC */
#define PINC7 7
#define PINC6 6
#define PINC5 5
#define PINC4 4
#define PINC3 3
#define PINC2 2
#define PINC1 1
#define PINC0 0
</c>

== Digitale Signale ==

Am einfachsten ist es, digitale Signale mit dem Mikrocontroller zu erfassen bzw. auszugeben.

== Ausgänge ==
Will man als Ausgang definierte Pins (entsprechende DDRx-Bits = 1) auf Logisch 1 setzen, setzt man die entsprechenden Bits im Portregister.

Mit dem Befehl
<c>
#include <avr/io.h>
...
PORTB = 0x04; /* besser PORTB=(1<<PB2) */

// übersichtliche Alternative - Binärschreibweise
PORTB = 0b00000100; /* direkte Zuweisung - übersichtlich */

</c>
wird also der Ausgang an Pin PB2 gesetzt (Beachte, dass die Bits immer ''von 0 an'' gezählt werden, das niederwertigste Bit ist also Bitnummer 0 und nicht etwa Bitnummer 1).

Man beachte, dass bei der Zuweisung mittels '''=''' immer alle Pins gleichzeitig angegeben werden. Man sollte also, wenn nur bestimmte Ausgänge geschaltet werden sollen, zuerst den aktuellen Wert des Ports einlesen und das Bit des gewünschten Ports in diesen Wert einfließen lassen. Will man also nur den dritten Pin (Bit Nr. 2) an Port B auf "high" setzen und den Status der anderen Ausgänge unverändert lassen, nutze man diese Form:

<c>
#include <avr/io.h>
...
PORTB = PORTB | 0x04; /* besser: PORTB = PORTB | ( 1<<PB2 ) */
/* vereinfacht durch Nutzung des |= Operators : */
PORTB |= (1<<PB2);

/* auch mehrere "gleichzeitig": */
PORTB |= (1<<PB4) | (1<<PB5); /* Pins PB4 und PB5 "high" */
</c>

"Ausschalten", also Ausgänge auf "low" setzen, erfolgt analog:

<c>
#include <avr/io.h>
...
PORTB &= ~(1<<PB2); /* löscht Bit 2 in PORTB und setzt damit Pin PB2 auf low */
PORTB &= ~( (1<<PB4) | (1<<PB5) ); /* Pin PB4 und Pin PB5 "low" */
</c>
Siehe auch [[Bitmanipulation]]

In Quellcodes, die für ältere Version den des avr-gcc/der avr-libc entwickelt wurden, werden einzelne Bits mittels der Funktionen sbi und cbi gesetzt bzw. gelöscht. Beide Funktionen sind in aktuellen Versionen der avr-libc nicht mehr enthalten und auch nicht mehr erforderlich.

''Falls der Anfangszustand von Ausgängen kritisch ist, muss die Reihenfolge beachtet werden, mit der die Datenrichtung (DDRx) eingestellt und der Ausgabewert (PORTx) gesetzt wird:''

Für Ausgangspins, die mit Anfangswert "high" initialisiert werden sollen:
* zuerst die Bits im PORTx-Register setzen
* anschließend die Datenrichtung auf Ausgang stellen

Daraus ergibt sich die Abfolge für einen Pin, der bisher als Eingang mit abgeschaltetem Pull-Up konfiguriert war:
* setze PORTx: interner Pull-Up aktiv
* setze DDRx: Ausgang ("high")

Bei der Reihenfolge erst DDRx und dann PORTx kann es zu einem kurzen "low-Puls" kommen, der auch externe Pull-Up-Widerstände "überstimmt". Die (ungünstige) Abfolge: Eingang -> setze DDRx: Ausgang (auf "low", da PORTx nach Reset 0) -> setze PORTx: Ausgang auf high. Vergleiche dazu auch das Datenblatt Abschnitt ''Configuring the Pin''.

== Eingänge (Wie kommen Signale in den µC) ==

Die digitalen Eingangssignale können auf verschiedene Arten zu unserer Logik gelangen.

=== Signalkopplung ===

Am einfachsten ist es, wenn die Signale direkt aus einer anderen digitalen Schaltung übernommen werden können. Hat der Ausgang der entsprechenden Schaltung TTL-Pegel dann können wir sogar direkt den Ausgang der Schaltung mit einem Eingangspin von unserem Controller verbinden.

Hat der Ausgang der anderen Schaltung keinen TTL-Pegel so müssen wir den Pegel über entsprechende Hardware (z. B. Optokoppler, [[Widerstand#Spannungsteiler|Spannungsteiler]], "Levelshifter" aka [[Pegelwandler]]) anpassen.

Die Masse der beiden Schaltungen muss selbstverständlich miteinander verbunden werden. Der Software selber ist es natürlich letztendlich egal, wie das Signal eingespeist wird. Wir können ja ohnehin lediglich prüfen, ob an einem Pin unseres Controllers eine logische 1 (Spannung größer ca. 0,7*Vcc) oder eine logische 0 (Spannung kleiner ca. 0,2*Vcc) anliegt. Detaillierte Informationen darüber, ab welcher Spannung ein Eingang als 0 ("low") bzw. 1 ("high") erkannt wird, liefert die Tabelle DC Characteristics im Datenblatt des genutzten Controllers.

{| class="wikitable" style="text-align:center"
|+ '''Spannungstabelle''' (ca. Grenzwerte)
|
! Low || High
|-
! bei 5 V
| 1 V || 3,5 V
|-
! bei 3,3 V
| 0,66 V || 2,31 V
|-
! bei 1,8 V
| 0,36 V || 1,26 V
|}

Die Abfrage der Zustände der Portpins erfolgt direkt über den Registernamen.

{{Warnung|Dabei ist wichtig, zur Abfrage der Eingänge ''nicht'' etwa Portregister '''PORTx''' zu verwenden, sondern Eingangsregister '''PINx'''. Ansonsten liest man nicht den Zustand der Eingänge, sondern den Status der internen Pull-Up-Widerstände. Die Abfrage der Pinzustände über PORTx statt PINx ist ein häufiger Fehler beim AVR-"Erstkontakt".}}

Will man also die aktuellen Signalzustände von Port D abfragen und in eine Variable namens bPortD abspeichern, schreibt man folgende Befehlszeilen:

<c>
#include <avr/io.h>
#include <stdint.h>
...
uint8_t bPortD;
...
bPortD = PIND;
...
</c>

Mit den C-Bitoperationen kann man den Status der Bits abfragen.

<c>
#include <avr/io.h>
...
/* Fuehre Aktion aus, wenn Bit Nr. 1 (das "zweite" Bit) in PINC gesetzt (1) ist */
if ( PINC & (1<<PINC1) ) {
/* Aktion */
}

/* Fuehre Aktion aus, wenn Bit Nr. 2 (das "dritte" Bit) in PINB geloescht (0) ist */
if ( !(PINB & (1<<PINB2)) ) {
/* Aktion */
}
...
</c>
Siehe auch [[Bitmanipulation#Bits_prüfen]]

=== Interne Pull-Up Widerstände ===

Portpins für Ein- und Ausgänge (GPIO) eines AVR verfügen über zuschaltbare interne Pull-Up Widerstände (nominal mehrere 10kOhm, z. B. ATmega16 20-50kOhm). Diese können in vielen Fällen statt externer Widerstände genutzt werden.

Die internen Pull-Up Widerstände von Vcc zu den einzelnen Portpins werden über das Register ''' PORTx''' aktiviert bzw. deaktiviert, wenn ein Pin als ''' Eingang''' geschaltet ist.

Wird der Wert des entsprechenden Portpins auf 1 gesetzt, so ist der Pull-Up Widerstand aktiviert. Bei einem Wert von 0 ist der Pull-Up Widerstand nicht aktiv. Man sollte jeweils entweder den internen oder einen externen Pull-Up Widerstand verwenden, aber nicht beide zusammen.

Im Beispiel werden alle Pins des Ports D als Eingänge geschaltet und alle Pull-Up Widerstände aktiviert. Weiterhin wird Pin PC7 als Eingang geschaltet und dessen interner Pull-Up Widerstand aktiviert, ohne die Einstellungen für die anderen Portpins (PC0-PC6) zu verändern.

<c>
#include <avr/io.h>
...
DDRD = 0x00; /* alle Pins von Port D als Eingang */
PORTD = 0xff; /* interne Pull-Ups an allen Port-Pins aktivieren */
...
DDRC &= ~(1<<PC7); /* Pin PC7 als Eingang */
PORTC |= (1<<PC7); /* internen Pull-Up an PC7 aktivieren */
</c>

=== Tasten und Schalter ===

Der Anschluss mechanischer Kontakte an den Mikrocontroller, ist zwischen zwei unterschiedliche Methoden zu unterscheiden: ''Active Low'' und ''Active High''.

<gallery widths="300" heights="300" caption="Anschluss mechanischer Kontakte an einen µC">
Image:Active Low.gif|'''Active Low:''' Bei dieser Methode wird der Kontakt zwischen den Eingangspin des Controllers und Masse geschaltet. Damit bei offenem Schalter der Controller kein undefiniertes Signal bekommt, wird zwischen die Versorgungsspannung und den Eingangspin ein sogenannter '''Pull-Up''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffnetem Schalter auf logisch 1 zu ziehen.
Image:Active High.gif|'''Active High:''' Hier wird der Kontakt zwischen die Versorgungsspannung und den Eingangspin geschaltet. Damit bei offener Schalterstellung kein undefiniertes Signal am Controller ansteht, wird zwischen den Eingangspin und die Masse ein '''Pull-Down''' Widerstand geschaltet. Dieser dient dazu, den Pegel bei geöffneter Schalterstellung auf logisch 0 zu halten.
</gallery>

Der Widerstandswert von Pull-Up- und Pull-Down-Widerständen ist an sich nicht kritisch. Wird er allerdings zu hoch gewählt, ist die Wirkung eventuell nicht gegeben. Als üblicher Wert haben sich 10 kOhm eingebürgert. Die AVRs verfügen an den meisten Pins über zuschaltbare interne Pull-Up Widerstände (vgl. Abschnitt [[AVR-GCC-Tutorial#Interne Pull-Up Widerstände|Interne Pull-Up Widerstände]]), welche insbesondere wie hier bei Tastern und ähnlichen Bauteilen (z. B. Drehgebern) statt externer Bauteile verwendet werden können. Interne Pull-Down-Widerstand sind nicht verfügbar und müssen daher in Form zusätzlicher Bauteile in die Schaltung eingefügt werden.

==== (Tasten-)Entprellung ====

Siehe: ''[[Entprellung#Warteschleifen-Verfahren|Entprellung: Warteschleifen-Verfahren]]

= Analoge Ein- und Ausgabe =

Analoge Eingangswerte werden in der Regel über den AVR Analog-Digital-Converter (AD-Wandler, ADC) eingelesen, der in vielen Typen verfügbar ist (typisch 10bit Auflösung). Durch diesen werden analoge Signale (Spannungen) in digitale Zahlenwerte gewandelt. Bei AVRs, die über keinen internen AD-Wandler verfügen (z. B. ATmega162), kann durch externe Beschaltung (R/C-Netzwerk und Zeitmessung) die Funktion des AD-Wandlers simuliert werden.

Es gibt innerhalb der ATMega- und ATTiny-AVR Reihe keine Typen mit eingebautem Digital-Analog-Konverter (DAC) - diese Funktion ist erst ab der XMEGA-Reihe der AVR-Familie verfügbar, die aber wegen ihrer vielen Unterschiede im Umfang dieses Tutorials nicht behandelt wird.
Die Umsetzung zu einer analogen Spannung muss daher durch externe Komponenten vorgenommen werden. Das kann z. B. durch PWM und deren Filterung zu (fast) DC, oder einem sogenannten R2R-Netzwerk erfolgen.

Unabhängig davon besteht natürlich immer die Möglichkeit, spezielle Bausteine zur Analog-Digital- bzw. Digital-Analog-Wandlung zu nutzen und diese über eine digitale Schnittstelle (z.b. SPI oder I2C) mit einem AVR anzusteuern.

== AC (Analog Comparator) ==

Der Comparator vergleicht 2 Spannungen an den Pins AIN0 und AIN1 und gibt einen Status aus welche der beiden Spannungen größer ist. AIN0 Dient dabei als Referenzspannung (Sollwert) und AIN1 als Vergleichsspannung (Istwert). Als Referenzspannung kann auch alternativ eine interne Referenzspannung ausgewählt werden.

Liegt die Vergleichsspannung (IST) unter der der Referenzspannung (SOLL) gibt der Comparator eine logische 1 aus. Ist die Vergleichsspannung hingegen größer als die Referenzspannung wird eine logische 0 ausgegeben.

Der Comparator arbeitet völlig autark bzw. parallel zum Prozessor. Für mobile Anwendungen empfiehlt es sich ihn abzuschalten sofern er nicht benötigt wird, da er ansonsten Strom benötigt. Der Comparator kann interruptgesteuert abgefragt werden oder im Pollingbetrieb.

Das Steuer- bzw. Statusregister ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|+ '''ACSR - Analog Comparator Status Register'''
|-
! Bit
| 7|| 6|| 5|| 4|| 3|| 2|| 1|| 0
|-
! Name
| '''ACD'''|| '''ACBG'''|| '''ACO'''|| '''ACI'''|| '''ACIE'''|| '''ACIC'''|| '''ACIS1'''|| '''ACIS0'''
|-
! R/W
| R/W|| R/W|| R|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| n/a|| 0|| 0|| 0|| 0|| 0
|}

;Bit 7 ACD: Analog Comparator Disable: 0 = Comparator ein, 1 = Comparator aus. Wird dieses Bit geändert kann ein Interrupt ausgelöst werden. Soll dies vermieden werden muss das Bit 3 ACIE ggf. abgeschaltet werden.

;Bit 6 ACBG: Analog Comparator Bandgap Select: Ermöglicht das umschalten zwischen interner und externer Referenzspannung. 1 = interne (~1,3 Volt), 0 = externe Referenzspannung (an Pin AIN0)

;Bit 5 ACO: Analog Comparator Output: Hier wird das Ergebnis des Vergleichs angezeigt. Es liegt typischerweise nach 1-2 Taktzyklen vor.
:: IST < SOLL → 1
:: IST > SOLL → 0

;Bit 4 ACI: Analog Comparator Interrupt Flag: Dieses Bit wird von der Hardware gesetzt, wenn ein Interruptereignis, das in Bit 0 und 1 definiert ist, eintritt. Dieses Bit löst noch keinen Interrupt aus! Die Interruptroutine wird nur dann ausgeführt, wenn das Bit 3 ACIE gesetzt ist und global Interrupts erlaubt sind (I-Bit in SREG gesetzt). Das Bit 4 ACI wird wieder gelöscht, wenn die Interruptroutine ausgeführt wurde oder wenn es manuell auf 1! gesetzt wird. Das Bit kann für Abfragen genutzt werden, steuert oder konfiguriert aber nicht den Comparator.

;Bit 3 ACIE: Analog Comparator Interrupt Enable: Ist das Bit auf 1 gesetzt, wird immer ein Interrupt ausgelöst, wenn das Ereignis das in Bit 1 und 0 definiert ist, eintritt.

;Bit 2 ACIC: Analog Comparator Input Capture Enable: Wird das Bit gesetzt, wird der Comparatorausgang intern mit dem Counter 1 verbunden. Es könnten damit z.b. die Anzahl der Vergleiche im Counter1 gezählt werden. Um den Comparator an den Timer1 Input Capture Interrupt zu verbinden, muss im Timerregister das TICIE1 Bit auf 1 gesetzt werden. Der Trigger wird immer dann ausgelöst, wenn das in Bit 1 und 0 definierte Ereignis eintritt.

;Bit 1,0 ACIS1,ACIS0: Analog Comparator Interrupt select: Hier wird definiert, welche Ereignisse einen Interrupt auslösen sollen:
:* 00 = Interrupt auslösen bei jedem Flankenwechsel
:* 10 = Interrupt auslösen bei fallender Flanke
:* 11 = Interrupt auslösen bei steigender Flanke

Werden diese Bit geändert, kann ein Interrupt ausgelöst werden. Soll dies vermieden werden, muss das Bit 3 gelöscht werden.

== ADC (Analog Digital Converter) ==

Der Analog-Digital-Konverter (ADC) wandelt analoge Signale in digitale Werte um, welche vom Controller interpretiert werden können. Einige AVR-Typen haben bereits einen mehrkanaligen Analog-Digital-Konverter eingebaut. Die Feinheit, mit welcher ein analoges Signal aufgelöst werden kann, wird durch die Auflösung des ADC, d.h. durch die Anzahl der verwendeten Bits angegeben. So sind derzeit bspw. 8-Bit- oder 10-Bit-ADC im Einsatz. ADCs, die in AVRs enthalten sind, haben zur Zeit eine maximale Auflösung von 10-Bit.

Ein ADC mit 8 Bit Auflösung kann somit das analoge Signal in Abstufungen von 1/256 des Maximalwertes digitalisieren. Wenn wir nun mal annehmen, wir hätten eine Eingangspannung zwischen 0 und 5 Volt, eine Referenzspannung von 5 V und eine Auflösung von 3 Bit, dann könnten
Intervalle mit den Grenzen 0 V, 0.625 V, 1.25 V, 1.875 V, 2.5 V, 3.125 V, 3.75 V, 4.375 V, 5 V entsprechend folgender Tabelle unterschieden werden:

::{| class="wikitable" style="text-align:center"
! Eingangsspannung am ADC / V || Entsprechender Messwert
|-
| 0 – 0.625 || 0
|-
| 0.625 – 1.25 || 1
|-
| 1.25 – 1.875 || 2
|-
| 1.875 – 2.5 || 3
|-
| 2.5 – 3.125 || 4
|-
| 3.125 – 3.75 || 5
|-
| 3.75 – 4.375 || 6
|-
| 4.375 – 5 || 7
|}

Die Angaben sind natürlich nur ungefähr. Je höher nun die Auflösung des Analog-Digital-Konverters ist, also, je mehr Bits er hat, desto genauer kann der jeweilige Wert erfasst werden.

=== Der interne ADC im AVR ===

Oft sind auch mehrere Kanäle verfügbar. Kanäle heißt in diesem Zusammenhang, dass zwar bis zu zehn analoge Eingänge am AVR vorhanden sind, aber nur ein "echter" Analog-Digital-Wandler zur Verfügung steht. Vor der eigentlichen Messung ist also festzulegen, welcher Kanal ("Pin") mit dem Wandler verbunden und gemessen wird.

Die Umwandlung innerhalb des AVR basiert auf der schrittweisen Näherung. Beim AVR müssen die Pins '''AGND''' und '''AVCC''' beschaltet werden. Für genaue Messungen sollte AVCC über ein L-C Netzwerk mit VCC verbunden werden, um Spannungsspitzen und -einbrüche vom Analog-Digital-Wandler fernzuhalten. Im Datenblatt findet sich dazu eine Schaltung, die 10µH und 100nF vorsieht.

Das Ergebnis der Analog-Digital-Wandlung wird auf eine Referenzspannung bezogen. Aktuelle AVRs bieten drei Möglichkeiten zur Wahl dieser Spannung:

* Eine externe Referenzspannung von maximal '''Vcc''' am Anschlusspin '''AREF'''. Die minimale (externe) Referenzspannung darf jedoch nicht beliebig niedrig sein, vgl. dazu das (aktuellste) Datenblatt des verwendeten Controllers.

* Verfügt der AVR über eine interne Referenzspannung, kann diese genutzt werden. Alle aktuellen AVRs mit internem AD-Wandler sollten damit ausgestattet sein (vgl. Datenblatt: 2,56V oder 1,1V je nach Typ). Das Datenblatt gibt auch über die Genauigkeit dieser Spannung Auskunft.

* Es kann die Spannung AVcc als Referenzspannung herangezogen werden

Bei Nutzung von AVcc oder der internen Referenz wird empfohlen, einen Kondensator zwischen dem AREF-Pin und GND anzuordnen. Die Festlegung, welche Spannungsreferenz genutzt wird, erfolgt z. B. beim ATmega16 mit den Bits REFS1/REFS0 im ADMUX-Register. Die zu messende Spannung muss im Bereich zwischen '''AGND''' und '''AREF''' (egal ob intern oder extern) liegen.

Der '''ADC''' kann in zwei verschiedenen Betriebsarten verwendet werden:

; Einfache Wandlung (Single Conversion) : In dieser Betriebsart wird der Wandler bei Bedarf vom Programm angestoßen für jeweils eine Messung.

; Frei laufend (Free Running) : In dieser Betriebsart erfasst der Wandler permanent die anliegende Spannung und schreibt diese in das '''ADC Data Register'''.

==== Die Register des ADC ====

Der '''ADC''' verfügt über eigene Register. Im Folgenden die Registerbeschreibung eines ATMega16, welcher über 8 ADC-Kanäle verfügt. Die Register unterscheiden sich jedoch nicht erheblich von denen anderer AVRs (vgl. Datenblatt).

{| class="wikitable"
|-
| '''ADCSRA   '''
| '''ADC''' '''C'''ontrol and '''S'''tatus '''R'''egister A. 
In diesem Register stellen wir ein, wie wir den '''ADC''' verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7|| 6|| 5|| 4|| 3|| 2|| 1|| 0
|-
! Name
| '''ADEN'''|| '''ADSC'''|| '''ADFR'''|| '''ADIF'''|| '''ADIE'''|| '''ADPS2'''|| '''ADPS1'''|| '''ADPS0'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''ADEN''' ('''AD'''C '''En'''able)
:Dieses Bit muss gesetzt werden, um den ''' ADC''' überhaupt zu aktivieren. Wenn das Bit nicht gesetzt ist, können die Pins wie normale I/O-Pins verwendet werden.

'''ADSC''' ('''AD'''C '''S'''tart '''C'''onversion)
:Mit diesem Bit wird ein Messvorgang gestartet. In der frei laufenden Betriebsart muss das Bit gesetzt werden, um die kontinuierliche Messung zu aktivieren.
:Wenn das Bit nach dem Setzen des '''ADEN'''-Bits zum ersten Mal gesetzt wird, führt der Controller zuerst eine zusätzliche Wandlung und erst dann die eigentliche Wandlung aus. Diese zusätzliche Wandlung wird zu Initialisierungszwecken durchgeführt.
:Das Bit bleibt nun so lange auf 1, bis die Umwandlung abgeschlossen ist, im Initialisierungsfall entsprechend bis die zweite Umwandlung erfolgt ist und geht danach auf 0.

'''ADFR''' ('''AD'''C '''F'''ree '''R'''un select)
:Mit diesem Bit wird die Betriebsart eingestellt.
:Ist das Bit auf 1 gesetzt arbeitet der ADC im "Free Running"-Modus. Dabei wird das Datenregister permanent aktualisiert. Ist das Bit hingegen auf 0 gesetzt, macht der ADC nur eine "Single Conversion".

'''ADIF''' ('''AD'''C '''I'''nterrupt '''F'''lag)
:Dieses Bit wird vom ''' ADC''' gesetzt, sobald eine Umwandlung erfolgt ist und das '''ADC Data Register''' aktualisiert wurde. Das Bit wird bei lesendem Zugriff auf '''ADC(L,H)''' automatisch (d.h. durch die Hardware) gelöscht.
:Wenn das '''ADIE''' Bit sowie das '''I-Bit''' im AVR '''Statusregister''' gesetzt ist, wird der '''ADC Interrupt''' ausgelöst und die Interrupt-Behandlungsroutine aufgerufen.
:Das Bit wird automatisch gelöscht, wenn die Interrupt-Behandlungsroutine aufgerufen wird. Es kann jedoch auch gelöscht werden, indem eine logische '''1'''! in das Register geschrieben wird.

'''ADIE''' ('''AD'''C '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist und ebenso das ''' I-Bit''' im Statusregister '''SREG''', dann wird der ''' ADC-Interrupt''' aktiviert.

'''ADPS2...ADPS0''' ('''AD'''C '''P'''rescaler '''S'''elect Bits)
:Diese Bits bestimmen den Teilungsfaktor zwischen der Taktfrequenz und dem Eingangstakt des '''ADC'''.
:Der '''ADC''' benötigt einen eigenen Takt, welchen er sich selber aus der CPU-Taktfreqenz erzeugt. Der '''ADC'''-Takt sollte zwischen 50 und 200kHz liegen.
:Der Vorteiler muss also so eingestellt werden, dass CPU-Taktfrequenz dividiert durch den Teilungsfaktor einen Wert im Bereich '''(50-200)kHz''' ergibt.
:Bei einer CPU-Taktfrequenz von 4MHz beispielsweise rechnen wir

:<math>
\begin{matrix}
TF_{min}=\frac{CLK}{200\,\mathrm{kHz}}=\frac{4000000}{200000}=\mathbf{20}
\\
\\
TF_{max}=\frac{CLK}{50\,\mathrm{kHz}}=\frac{4000000}{50000}=\mathbf{80}
\end{matrix}
</math>

:Somit kann hier der Teilungsfaktor 32 oder 64 verwendet werden. Im Interesse der schnelleren Wandlungszeit werden wir hier den Faktor 32 einstellen.

:{| class="wikitable" style="text-align:center"
|-
! '''ADPS2'''|| '''ADPS1'''|| '''ADPS0'''|| '''Teilungsfaktor'''
|-
| 0|| 0|| 0|| 2
|-
| 0|| 0|| 1|| 2
|-
| 0|| 1|| 0|| 4
|-
| 0|| 1|| 1|| 8
|-
| 1|| 0|| 0|| 16
|-
| 1|| 0|| 1|| 32
|-
| 1|| 1|| 0|| 64
|-
| 1|| 1|| 1|| 128
|}

|-
| '''ADCL''' 
'''ADCH'''
| '''ADC ''' Data Register 
Wenn eine Umwandlung abgeschlossen ist, befindet sich der gemessene Wert in
diesen beiden Registern. Von '''ADCH''' werden nur die beiden niederwertigsten Bits verwendet. Es müssen immer beide Register ausgelesen werden, und zwar immer '''in der Reihenfolge: ADCL, ADCH'''.
Der effektive Messwert ergibt sich dann zu:

<c>
x = ADCL; // mit uint16_t x
x += (ADCH<<8); // in zwei Zeilen (LSB/MSB-Reihenfolge und
// C-Operatorpriorität sichergestellt)
</c>

oder

<c>
x = ADCW; // je nach AVR auch x = ADC (siehe avr/ioxxx.h)
</c>

|-
| '''ADMUX  '''
| '''AD'''C '''Mu'''ltiple'''x'''er Select Register 
Mit diesem Register wird der zu messende Kanal ausgewählt. Beim 90S8535
kann jeder Pin von Port A als '''ADC'''-Eingang verwendet werden (=8 Kanäle). 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7|| 6|| 5|| 4|| 3|| 2|| 1|| 0
|-
! Name
| '''REFS1'''|| '''REFS0'''|| '''ADLAR'''|| '''MUX4'''|| '''MUX3'''|| '''MUX2'''|| '''MUX1'''|| '''MUX0'''
|-
! '''R/W'''
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''REFS1...REFS0''' ('''Ref'''erence'''S'''election Bits)
:Mit diesen Bits kann die Referenzspannung eingestellt werden. Bei der Umstellung sind Wartezeiten zu beachten, bis die ADC-Hardware einsatzfähig ist (Datenblatt und [http://www.mikrocontroller.net/topic/165513]):

{| class="wikitable" style="text-align:center"
|-
! '''REFS1'''|| '''REFS0'''|| '''Referenzspanung'''
|-
| 0|| 0|| Externes AREF
|-
| 0|| 1|| AVCC als Referenz
|-
| 1|| 0|| Reserviert
|-
| 1|| 1|| Interne 2,56 Volt
|}

'''ADLAR''' ('''ADC ''' '''L'''eft '''A'''djust '''R'''esult)
:Das ADLAR Bit verändert das Aussehen des Ergebnisses der AD-Wandlung. Bei einer logischen 1 wird das Ergebnis linksbündig ausgegeben, bei einer 0 rechtsbündig. Eine Änderung in diesem Bit beeinflusst das Ergebnis sofort, ganz egal ob bereits eine Wandlung läuft.

'''MUX4...MUX0'''
:Mit diesen 5 Bits wird der zu messende Kanal bestimmt. Wenn man einen einfachen 1-kanaligen ADC verwendet wird einfach die entsprechende Pinnummer des Ports in die Bits 0...4 eingeschrieben (je nach Anzahl der Wandler des AVR, bei 8 AD-Kanälen halt nur 0...2).
:Wenn das Register beschrieben wird, während eine Umwandlung läuft, so wird zuerst die aktuelle Umwandlung auf dem bisherigen Kanal beendet. Dies ist vor allem beim frei laufenden Betrieb zu berücksichtigen.

:Eine Empfehlung ist deswegen diese, dass der frei laufende Betrieb nur bei einem einzelnen zu verwendenden Analogeingang verwendet werden sollte, wenn man sich Probleme bei der Umschalterei ersparen will.
|}

==== Nutzung des ADC ====

Um den ''' ADC''' zu aktivieren, müssen wir das '''ADEN'''-Bit im '''ADCSR'''-Register setzen. Im gleichen Schritt legen wir auch die Betriebsart fest.

Im Folgenden ein kleines Beispiel für den "single conversion"-Mode bei einem ATmega169 und Nutzung der internen Referenzspannung (beim '169 1,1V bei anderen AVRs auch 2,56V, vgl. Datenblatt). D.h. das Eingangssignal darf diese Spannung nicht überschreiten, gegebenenfalls muss es mit einem [[Spannungsteiler]] verringert werden. Das Ergebnis der Routine ist der ADC-Wert, also 0 für 0-Volt und 1023 für V_ref-Volt. Beim Programmstart wir der ADC konfiguriert und aktiviert und dann auf verschiedenen Kanälen die Spannung gemessen. Initialisierung des ADC und die Wandlungen sollte man trennen, denn das Einschalten des ADC und vor allem der Referenzspannung dauert ein paar Dutzend Mikrosekunden. Außerdem ist das erste Ergebnis nach dem Einschalten ungültig und muss verworfen werden.

<c>
// Diese Beispiel zeigt die Anwendung des ADC eines ATmega169
// unter Verwendung der internen Referenzspannung von nominell 1,1V.
// Zur Anpassung an andere AVR und/oder andere Referenzspannungen
// siehe Erläuterungen in diesem Tutorial und im Datenblatt

/* ADC initialisieren */
void ADC_Init(void) {

uint16_t result;

// interne Referenzspannung als Refernz für den ADC wählen:
ADMUX = (1<<REFS1) | (1<<REFS0);

// Bit ADFR ("free running") in ADCSRA steht beim Einschalten
// schon auf 0, also single conversion
ADCSRA = (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler
ADCSRA |= (1<<ADEN); // ADC aktivieren

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

ADCSRA |= (1<<ADSC); // eine ADC-Wandlung
while (ADCSRA & (1<<ADSC) ) {} // auf Abschluss der Konvertierung warten
/* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
Wandlung nicht übernommen. */
result = ADCW;
}

/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
// Kanal waehlen, ohne andere Bits zu beeinflußen
ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion"
while (ADCSRA & (1<<ADSC) ) {} // auf Abschluss der Konvertierung warten
return ADCW; // ADC auslesen und zurückgeben
}

/* ADC Mehrfachmessung mit Mittelwertbbildung */
/* beachte: Wertebereich der Summenvariablen */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t nsamples )
{
uint32_t sum = 0;

for (uint8_t i = 0; i < nsamples; ++i ) {
sum += ADC_Read( channel );
}

return (uint16_t)( sum / nsamples );
}

...

/* Beispielaufrufe: */

int main()
{
uint16_t adcval;
ADC_Init();

while( 1 ) {
adcval = ADC_Read(0); // Kanal 0
// mach was mit adcval

adcval = ADC_Read_Avg(2, 4); // Kanal 2, Mittelwert aus 4 Messungen
// mach was mit adcval
}
}

</c>

Im Beispiel läuft der ADC ständig. Für den Fall, dass man Strom sparen will, z.B. mittels Verwendung des [[Sleep Mode]]s, muss man den ADC nach jeder Messung abschalten und vor der nächsten Messung wieder einschalten, wobei auch dann wieder eine kleine Pause und Anfangswandlung nötig sind.



=== Analog-Digital-Wandlung ohne internen ADC ===

==== Messen eines Widerstandes ====

[[Image:Poti.gif|framed|right]]
Analoge Werte lassen sich ohne Analog-Digital-Wandler auch indirekt ermitteln. Im Folgenden wird die Messung des an einem Potentiometer eingestellten Widerstands anhand der Ladekurve eines Kondensators erläutert. Bei dieser Methode wird nur ein Portpin benötigt, ein Analog-Digital-Wandler oder Analog-Comparator ist nicht erforderlich. Es wird dazu ein Kondensator und der Widerstand (das Potentiometer) in Reihe zwischen Vorsorgungsspannung und Masse/GND geschaltet (sogen. RC-Netzwerk). Zusätzlich wird eine Verbindung der Leitung zwischen Kondensator und Potentiometer zu einem Portpin des Controllers hergestellt. Die folgende Abbildung verdeutlicht die erforderliche Schaltung.

Wird der Portpin des Controllers auf Ausgang konfiguriert (im Beispiel ''DDRD |= (1<<PD2)'') und dieser Ausgang auf Logisch 1 ("High", ''PORTD |= (1<<PD2)'') geschaltet, liegt an beiden "Platten" des Kondensators das gleiche Potential '''VCC''' an und der Kondensator somit entladen. (Klingt komisch, mit ''' Vcc''' entladen, ist aber so, da an beiden Seiten des Kondensators das gleiche Potential anliegt und somit eine Potentialdifferenz von 0V besteht => Kondensator ist entladen).

Nach einer gewissen Zeit ist der Kondensator entladen und der Portpin wird als Eingang konfiguriert (''DDRD &= ~(1<<PD2); PORTD &= ~(1<<PD2)''), wodurch dieser hochohmig wird. Der Status des Eingangspin (in PIND) ist Logisch 1 (High). Der Kondensator lädt sich jetzt über das Poti auf, dabei steigt der Spannungsabfall über dem Kondensator und derjenige über dem Poti sinkt. Fällt nun der Spannungsabfall über dem Poti unter die Threshold-Spannung des Eingangspins (2/5 Vcc, also ca. 2V), wird das Eingangssignal als LOW erkannt (Bit in PIND wird 0). Die Zeitspanne zwischen der Umschaltung von Entladung auf Aufladung und dem Wechsel des Eingangssignals von High auf Low ist ein Maß für den am Potentiometer eingestellten Widerstand. Zur Zeitmessung kann einer der im Controller vorhandenen Timer genutzt werden. Der 220Ω Widerstand dient dem Schutz des Controllers. Es würde sonst bei Maximaleinstellung des Potentionmeters (hier 0Ω) ein zu hoher Strom fließen, der die Ausgangsstufe des Controllers zerstört.

Mit einem weiteren Eingangspin und ein wenig Software können wir auch eine Kalibrierung realisieren, um den Messwert in einen vernünftigen Bereich (z.B: 0...100 % oder so) umzurechnen.



==== ADC über Komparator ====

[[Image:ADC ueber Komparator.gif|framed|right]]
Es gibt einen weiteren Weg, eine analoge Spannung mit Hilfe des
Komparators, welcher in fast jedem AVR integriert ist, zu messen. Siehe dazu
auch die Application Note AVR400 von Atmel.

Dabei wird das zu messende Signal auf den invertierenden Eingang
des Komparators geführt. Zusätzlich wird ein Referenzsignal an den nicht
invertierenden Eingang des Komparators angeschlossen. Das Referenzsignal wird
hier auch wieder über ein RC-Glied erzeugt, allerdings mit festen Werten für R
und C.

Das Prinzip der Messung ist nun dem vorhergehenden recht
ähnlich. Durch Anlegen eines LOW-Pegels an Pin 2 wird der Kondensator zuerst
einmal entladen. Auch hier muss darauf geachtet werden, dass der Entladevorgang
genügend lang dauert.
Nun wird Pin 2 auf HIGH gelegt. Der Kondensator wird geladen. Wenn die Spannung
über dem Kondensator die am Eingangspin anliegende Spannung erreicht hat,
schaltet der Komparator durch. Die Zeit, welche benötigt wird, um den
Kondensator zu laden, kann nun auch wieder als Maß für die Spannung an Pin 1
herangezogen werden.

Ich habe es mir gespart, diese Schaltung auch aufzubauen, und zwar aus mehreren Gründen:

# 3 Pins notwendig.
# Genauigkeit vergleichbar mit einfacherer Lösung.
# War einfach zu faul.

Der Vorteil dieser Schaltung liegt allerdings darin, dass damit direkt Spannungen gemessen werden können.

== DAC (Digital Analog Converter) ==

Mit Hilfe eines Digital-Analog-Konverters ('''DAC''') können wir nun auch Analogsignale ausgeben. Es gibt hier mehrere Verfahren. 

=== DAC über mehrere digitale Ausgänge ===

Wenn wir an den Ausgängen des Controllers ein entsprechendes
Widerstandsnetzwerk aufbauen haben wir die Möglichkeit, durch die Ansteuerung
der Ausgänge über den Widerständen einen Addierer aufzubauen, mit dessen
Hilfe wir eine dem Zahlenwert proportionale Spannung erzeugen können. Das
Schaltbild dazu kann etwa so aussehen:

[[Image:DAC R2R.gif]]

Es sollten selbstverständlich möglichst genaue Widerstände verwendet
werden, also nicht unbedingt solche mit einer Toleranz von 10% oder mehr.
Weiterhin empfiehlt es sich, je nach Anwendung den Ausgangsstrom über einen
Operationsverstärker zu verstärken.

=== PWM (Pulsweitenmodulation) ===

Wir kommen nun zu einem Thema, welches in aller Munde ist, aber viele
Anwender verstehen nicht ganz, wie [[PWM]] eigentlich funktioniert.

Wie wir alle wissen, ist ein Mikrocontroller ein rein digitales Bauteil.
Definieren wir einen Pin als Ausgang, dann können wir diesen Ausgang entweder
auf HIGH setzen, worauf am Ausgang die Versorgungsspannung ''' Vcc''' anliegt, oder aber wir setzen den Ausgang auf LOW, wonach dann ''' 0V''' am Ausgang liegt. Was passiert aber nun, wenn wir periodisch mit einer festen Frequenz zwischen HIGH und LOW umschalten? - Richtig, wir erhalten eine Rechteckspannung, wie die folgende Abbildung zeigt:

[[Image:PWM Theorie 1.gif]]

Diese Rechteckspannung hat nun einen arithmetischen Mittelwert,
der je nach Pulsbreite kleiner oder größer ist.

[[Image:PWM Theorie 2.gif]]

Wenn wir nun diese pulsierende Ausgangsspannung noch über ein RC-Glied filtern/"glätten", dann haben wir schon eine entsprechende Gleichspannung erzeugt.

Mit den AVRs können wir direkt PWM-Signale erzeugen.
Dazu dient der 16-Bit Zähler, welcher im sogenannten PWM-Modus betrieben werden kann.

;Hinweis: In den folgenden Überlegungen wird als Controller der 90S2313 vorausgesetzt. Die Theorie ist bei anderen AVR-Controllern vergleichbar, die Pinbelegung allerdings nicht unbedingt, weshalb ein Blick ins entsprechende Datenblatt dringend angeraten wird.

Um den PWM-Modus zu aktivieren, müssen im Timer/Counter1 Control
Register A TCCR1A die Pulsweiten-Modulatorbits PWM10 bzw. PWM11 entsprechend nachfolgender Tabelle gesetzt werden:

{| class="wikitable" style="text-align:center"
|-
! PWM11 || PWM10 || Bedeutung
|-
| 0 || 0 || PWM-Modus des Timers ist nicht aktiv
|-
| 0 || 1 || 8-Bit PWM
|-
| 1 || 0 || 9-Bit PWM
|-
| 1 || 1 || 10-Bit PWM
|}

Der Timer/Counter zählt nun permanent von 0 bis zur Obergrenze
und wieder zurück, er wird also als sogenannter Auf-/Ab Zähler betrieben.
Die Obergrenze hängt davon ab, ob wir mit 8, 9 oder 10-Bit PWM arbeiten wollen:

{| class="wikitable"
|-
! Auflösung || Obergrenze || Frequenz
|-
| align="center" | 8
| align="center" | 255
| fTC1 / 510
|-
| align="center" | 9
| align="center" | 511
| fTC1 / 1022
|-
| align="center" | 10
| align="center" | 1023
| fTC1 / 2046
|}

Zusätzlich muss mit den Bits '''COM1A1''' und '''COM1A0''' desselben
Registers die gewünschte Ausgabeart des Signals definiert werden:

{| class="wikitable"
|-
! COM1A1 || COM1A0 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 0
| align="center" | 1
| Keine Wirkung, Pin wird nicht geschaltet.
|-
| align="center" | 1
| align="center" | 0
| Nicht invertierende PWM. 
Der Ausgangspin wird gelöscht beim Hochzählen und gesetzt beim
Herunterzählen.
|-
| align="center" | 1
| align="center" | 1
| Invertierende PWM. 
Der Ausgangspin wird gelöscht beim Herunterzählen und gesetzt beim
Hochzählen.
|}

Der entsprechende Befehl, um beispielsweise den Timer/Counter als
nicht invertierenden 10-Bit PWM zu verwenden, heißt dann:

alte Schreibweise (PWMxx wird nicht mehr akzeptiert)
<c>
TCCR1A = (1<<PWM11)|(1<<PWM10)|(1<<COM1A1);
</c>
neue Schreibweise
<c>
TCCR1A = (1<<WGM11)|(1<<WGM10)|(1<<COM1A1);
</c>

Damit der Timer/Counter überhaupt läuft, müssen wir im Control
Register B '''TCCR1B''' noch den gewünschten Takt (Vorteiler) einstellen und
somit auch die Frequenz des '''PWM'''-Signals bestimmen.

{| class="wikitable"
|-
! CS12 || CS11 || CS10 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| align="center" | 0
| Stop. Der Timer/Counter wird gestoppt.
|-
| align="center" | 0
| align="center" | 0
| align="center" | 1
| CK
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| CK / 8
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| CK / 64
|-
| align="center" | 1
| align="center" | 0
| align="center" | 0
| CK / 256
|-
| align="center" | 1
| align="center" | 0
| align="center" | 1
| CK / 1024
|-
| align="center" | 1
| align="center" | 1
| align="center" | 0
| Externer Pin 1, negative Flanke
|-
| align="center" | 1
| align="center" | 1
| align="center" | 1
| Externer Pin 1, positive Flanke
|}

Also um einen Takt von CK / 1024 zu generieren, verwenden wir
folgenden Befehl:

<c>
TCCR1B = (1<<CS12) | (1<<CS10);
</c>

Jetzt muss nur noch der Vergleichswert festgelegt werden. Diesen
schreiben wir in das 16-Bit Timer/Counter Output Compare Register '''OCR1A'''.

<c>
OCR1A = xxx;
</c>

Die folgende Grafik soll den Zusammenhang zwischen dem Vergleichswert und dem generierten '''PWM'''-Signal aufzeigen.

[[Image:PWM Theorie 3.gif]]

[[Image:PWM Theorie 4.gif]]

Ach ja, fast hätte ich's vergessen. Das generierte '''PWM'''-Signal
wird am Output Compare Pin '''OC1''' des Timers ausgegeben und leider können wir
deshalb auch beim AT90S2313 nur ein einzelnes '''PWM'''-Signal mit dieser Methode generieren. Andere AVR-Typen verfügen über bis zu vier PWM-Ausgänge. Zu beachten ist außerdem, das wenn der OC Pin aktiviert ist, er nichtmehr wie üblich funktioniert und z. B. nicht einfach über PINx ausgelesen werden kann.

Ein Programm, welches an einem ATmega8 den Fast-PWM Modus verwendet, den Modus 14, könnte so aussehen
<C>
#include <avr/io.h>

int main()
{
// OC1A auf Ausgang
DDRB = (1 << PB1 ); //ATMega8
// DDRD = (1 << PD5 ); //ATMega16
//
// Timer 1 einstellen
//
// Modus 14:
// Fast PWM, Top von ICR1
//
// WGM13 WGM12 WGM11 WGM10
// 1 1 1 0
//
// Timer Vorteiler: 1
// CS12 CS11 CS10
// 0 0 1
//
// Steuerung des Ausgangsport: Set at BOTTOM, Clear at match
// COM1A1 COM1A0
// 1 0

TCCR1A = (1<<COM1A1) | (1<<WGM11);
TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS10);

// den Endwert (TOP) für den Zähler setzen
// der Zähler zählt bis zu diesem Wert

ICR1 = 0x6FFF;

// der Compare Wert
// Wenn der Zähler diesen Wert erreicht, wird mit
// obiger Konfiguration der OC1A Ausgang abgeschaltet
// Sobald der Zähler wieder bei 0 startet, wird der
// Ausgang wieder auf 1 gesetzt
//
// Durch Verändern dieses Wertes, werden die unterschiedlichen
// PWM Werte eingestellt.

OCR1A = 0x3FFF;

while (1) {}
}
</C>

{| class="wikitable" style="text-align:center"
|+ '''PWM-Mode Tabelle aus dem Datenblatt des ATmega8515'''
|-
!Mode || WGM13 || WGM12 || WGM11 || WGM10 || Timer/Counter Mode of Operation
! TOP|| Update of OCR1x at || TOV1 Flag set on
|-
! 0
| 0
| 0
| 0
| 0
| Normal
| 0xFFFF
| Immediate
| MAX
|-
! 1
| 0
| 0
| 0
| 1
| PWM, Phase Correct, 8-Bit
| 0x00FF
| TOP
| BOTTOM
|-
! 2
| 0
| 0
| 1
| 0
| PWM, Phase Correct, 9-Bit
| 0x01FF
| TOP
| BOTTOM
|-
! 3
| 0
| 0
| 1
| 1
| PWM, Phase Correct, 10-Bit
| 0x03FF
| TOP
| BOTTOM
|-
! 4
| 0
| 1
| 0
| 0
| CTC
| OCR1A
| Immediate
| MAX
|-
! 5
| 0
| 1
| 0
| 1
| Fast PWM, 8-Bit
| 0x00FF
| BOTTOM
| TOP
|-
! 6
| 0
| 1
| 1
| 0
| Fast PWM, 9-Bit
| 0x01FF
| BOTTOM
| TOP
|-
! 7
| 0
| 1
| 1
| 1
| Fast PWM, 10-Bit
| 0x03FF
| BOTTOM
| TOP
|-
! 8
| 1
| 0
| 0
| 0
| PWM, Phase an Frequency Correct
| ICR1
| BOTTOM
| BOTTOM
|-
! 9
| 1
| 0
| 0
| 1
| PWM, Phase an Frequency Correct
| OCR1A
| BOTTOM
| BOTTOM
|-
! 10
| 1
| 0
| 1
| 0
| PWM, Phase Correct
| ICR1
| TOP
| BOTTOM
|-
! 11
| 1
| 0
| 1
| 1
| PWM, Phase an Frequency Correct
| OCR1A
| TOP
| BOTTOM
|-
! 12
| 1
| 1
| 0
| 0
| CTC
| ICR1
| Immediate
| MAX
|-
! 13
| 1
| 1
| 0
| 1
| Reserved
| -
| -
| -
|-
! 14
| 1
| 1
| 1
| 0
| Fast PWM
| ICR1
| BOTTOM
| TOP
|-
! 15
| 1
| 1
| 1
| 1
| Fast PWM
| OCR1A
| BOTTOM
| TOP
|}

Für Details der PWM-Möglichkeiten muss immer das jeweilige Datenblatt des Prozessors konsultiert werden, da sich die unterschiedlichen Prozessoren in ihren Möglichkeiten doch stark unterscheiden. Auch muss man aufpassen, welches zu setzende Bit in welchem Register ist. Auch hier kann es sein, dass gleichnamige Konfigurationsbits in unterschiedlichen Konfigurationsregistern (je nach konkretem Prozessortyp) sitzen.

= Warteschleifen (delay.h) =

Der Programmablauf kann verschiedene Arten von Wartefunktionen erfordern:

* Warten im Sinn von Zeitvertrödeln
* Warten auf einen bestimmten Zustand an den I/O-Pins
* Warten auf einen bestimmten Zeitpunkt (siehe Timer)
* Warten auf einen bestimmten Zählerstand (siehe Counter)

Der einfachste Fall, das Zeitvertrödeln, kann in vielen Fällen und mit großer Genauigkeit anhand der avr-libc Bibliotheksfunktionen _delay_ms() und _delay_us() erledigt werden. Die Bibliotheksfunktionen sind einfachen Zählschleifen (Warteschleifen) vorzuziehen, da leere Zählschleifen ohne besondere Vorkehrungen sonst bei eingeschalteter Optimierung vom avr-gcc-Compiler wegoptimiert werden. Weiterhin sind die Bibliotheksfunktionen bereits darauf vorbereitet, die in F_CPU definierte Taktfrequenz zu verwenden. Außerdem sind die Funktionen der Bibliothek wirklich getestet.

Einfach!? Schon, aber während gewartet wird, macht der µC nichts anderes mehr (abgesehen von möglicherweise auftretenden Interrupts, falls welche aktiviert sind). Die Wartefunktion blockiert den Programmablauf. Möchte man einerseits warten, um z. B. eine LED blinken zu lassen und gleichzeitig andere Aktionen ausführen z. B. weitere LED bedienen, sollten die Timer/Counter des AVR verwendet werden.

Die Bibliotheksfunktionen funktionieren allerdings nur dann korrekt, wenn sie mit zur Übersetzungszeit (beim Compilieren) bekannten konstanten Werten aufgerufen werden. Der Quellcode muss mit eingeschalteter Optimierung übersetzt werden, sonst wird sehr viel Maschinencode erzeugt, und die Wartezeiten stimmen nicht mehr mit dem Parameter überein.

Eine weitere Einschränkung liegt darin, daß sie möglicherweise länger warten, als erwartet, nämlich in dem Fall, daß Interrupts auftreten und die _delay...()-Funktion unterbrechen. Genau genommen warten diese nämlich nicht eine bestimmte Zeit, sondern verbrauchen eine bestimmte Anzahl von Prozessortakten. Die wiederum ist so bemessen, daß ohne Unterbrechung durch Interrupts die gewünschte Wartezeit erreicht wird.
Wird das Warten aber durch eine oder mehrere ISR unterbrochen, die zusammen 1% Prozessorzeit verbrauchen, dann dauert das Warten etwa 1% länger. Bei 50% Last durch die ISR dauert das Warten doppelt solange wie gewünscht, bei 90% zehnmal solange...

Abhängig von der Version der Bibliothek verhalten sich die Bibliotheksfunktionen etwas unterschiedlich.

== avr-libc Versionen kleiner 1.6 ==

Die Wartezeit der Funktion _delay_ms() ist auf 262,14ms/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 13,1ms warten. Die Wartezeit der Funktion _delay_us() ist auf 768us/F_CPU (in MHz) begrenzt, d.h. bei 20 MHz kann man nur max. 38,4µs warten. Längere Wartezeiten müssen dann über einen mehrfachen Aufruf in einer Schleife gelöst werden.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z. B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h> /* in älteren avr-libc Versionen <avr/delay.h> */

/*
lange, variable Verzögerungszeit, Einheit in Millisekunden

Die maximale Zeit pro Funktionsaufruf ist begrenzt auf
262.14 ms / F_CPU in MHz (im Beispiel:
262.1 / 3.6864 = max. 71 ms)

Daher wird die kleine Warteschleife mehrfach aufgerufen,
um auf eine längere Wartezeit zu kommen. Die zusätzliche
Prüfung der Schleifenbedingung lässt die Wartezeit geringfügig
ungenau werden (macht hier vielleicht 2-3ms aus).
*/

void long_delay(uint16_t ms)
{
for(; ms>0; ms--) _delay_ms(1);
}

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) // Endlosschleife
{
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z. B. angeschlossene LED
long_delay(1000); // Eine Sekunde warten...
}

return 0;
}
</c>

== avr-libc Versionen ab 1.6 ==

_delay_ms() kann mit einem Argument bis 6553,5 ms (= 6,5535 Sekunden) benutzt werden. Es ist nicht möglich, eine Variable als Argument zu übergeben. Wird die früher gültige Grenze von 262,14 ms/F_CPU (in MHz) überschritten, so arbeitet _delay_ms() einfach etwas ungenauer und zählt nur noch mit einer Auflösung von 1/10 ms. Eine Verzögerung von 1000,10 ms ließe sich nicht mehr von einer von 1000,19 ms unterscheiden. Ein Verlust, der sich im Allgemeinen verschmerzen lässt. Dem Programmierer wird keine Rückmeldung gegeben, dass die Funktion ggf. gröber arbeitet, d.h. wenn es darauf ankommt, bitte den Parameter wie bisher geschickt wählen.

Die Funktion _delay_us() wurde ebenfalls erweitert. Wenn deren maximal als genau behandelbares Argument überschritten wird, benutzt diese intern _delay_ms(). Damit gelten in diesem Fall die _delay_ms() Einschränkungen.

Beispiel: Blinken einer LED an PORTB Pin PB0 im ca. 1s Rhythmus, avr-libc ab Version 1.6
<c>
#include <avr/io.h>
#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
(z.B. durch Übergabe als Parameter zum Compiler innerhalb
des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
"nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h>

int main( void )
{
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z.B. angeschlossene LED
_delay_ms(1000); // Eine Sekunde +/-1/10000 Sekunde warten...
// funktioniert nicht mit Bibliotheken vor 1.6

}
return 0;
}
</c>

Trick zur Übergabe einer Variablen an _delay_ms():
<c>
#include <avr/io.h>
#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h>

void sleep ( uint8_t ms )
{
for(; ms > 0; ms--) _delay_ms(1);
}

int main( void )
{
int x = 0; // Variable als Wartezeit erstellen
DDRB = ( 1 << PB0 ); // PB0 an PORTB als Ausgang setzen

while( 1 ) { // Endlosschleife
PORTB ^= ( 1 << PB0 ); // Toggle PB0 z.B. angeschlossene LED
sleep(x);
x++;
}
return 0;
}
</c>

Die _delay_ms() und die _delay_us aus '''avr-libc 1.7.0''' sind fehlerhaft. _delay_ms () läuft 4x schneller als erwartet. Abhilfe ist eine korrigierte Includedatei: [http://www.mikrocontroller.net/topic/196738#1943039]

= Programmieren mit Interrupts =

<div style="float:right; margin:2em;">
[[Image:Interrupt Programme.gif]]
</div>
Nachdem wir nun alles Wissenswerte für die serielle Programmerstellung
gelernt haben nehmen wir jetzt ein völlig anderes Thema in Angriff, nämlich
die Programmierung unter Zuhilfenahme der Interrupts des AVR.

Als erstes wollen wir uns noch einmal den allgemeinen Programmablauf bei der
Interrupt-Programmierung zu Gemüte führen.

Man sieht, dass die Interruptroutine quasi parallel zum Hauptprogramm
abläuft. Da wir nur eine CPU haben ist es natürlich keine echte Parallelität,
sondern das Hauptprogramm wird beim Eintreffen eines Interrupts unterbrochen,
die Interruptroutine wird ausgeführt und danach erst wieder zum Hauptprogramm
zurückgekehrt.

Siehe auch

* [http://www.mikrocontroller.net/forum/read-1-235092.html#new Ausführlicher Thread im Forum]
* Artikel [[Interrupt]]
* Artikel [[Multitasking]]
{{Clear}}

== Anforderungen an Interrupt-Routinen ==

Um unliebsamen Überraschungen vorzubeugen, sollten einige Grundregeln bei der Implementierung der Interruptroutinen beachtet werden. Interruptroutinen sollten möglichst kurz und schnell abarbeitbar sein, daraus folgt:

* Keine umfangreichen Berechnungen innerhalb der Interruptroutine. (*)
* Keine langen Programmschleifen.
* Obwohl es möglich ist, während der Abarbeitung einer Interruptroutine andere oder sogar den gleichen Interrupt wieder zuzulassen, wird davon ohne genaue Kenntnis der internen Abläufe dringend abgeraten.

Interruptroutinen (ISRs) sollten also möglichst kurz sein und keine Schleifen mit vielen Durchläufen enthalten. Längere Operationen können meist in einen "Interrupt-Teil" in einer ISR und einen "Arbeitsteil" im Hauptprogramm aufgetrennt werden. Z.B. Speichern des Zustands aller Eingänge im EEPROM in bestimmten Zeitabständen: ISR-Teil: Zeitvergleich (Timer,RTC) mit Logzeit/-intervall. Bei Übereinstimmung ein globales Flag setzen (volatile bei Flag-Deklaration nicht vergessen, s.u.). Dann im Hauptprogramm prüfen, ob das Flag gesetzt ist. Wenn ja: die Daten im EEPROM ablegen und Flag löschen.

(*)
Hinweis:
Es gibt allerdings die seltene Situation, dass man gerade eingelesene
ADC-Werte sofort verarbeiten muss. Besonders dann, wenn man mehrere Werte sehr
schnell hintereinander bekommt. Dann bleibt einem nichts anderes übrig, als die
Werte noch in der ISR zu verarbeiten. Kommt aber sehr selten vor und sollte
durch geeignete Wahl des Systemtaktes bzw. Auswahl des Controllers vermieden werden!

== Interrupt-Quellen ==

Die folgenden Ereignisse können einen Interrupt auf einem AVR AT90S2313 auslösen, wobei die Reihenfolge der Auflistung auch die Priorität der Interrupts aufzeigt.

* Reset
* Externer Interrupt 0
* Externer Interrupt 1
* Timer/Counter 1 Capture Ereignis
* Timer/Counter 1 Compare Match
* Timer/Counter 1 Überlauf
* Timer/Counter 0 Überlauf
* UART Zeichen empfangen
* UART Datenregister leer
* UART Zeichen gesendet
* Analoger Komparator

Die Anzahl der möglichen Interruptquellen variiert zwischen den verschiedenen Microcontroller-Typen. Im Zweifel hilft ein Blick ins Datenblatt ("Interrupt Vectors").

== Register ==

Der AT90S2313 verfügt über 2 Register die mit den
Interrupts zusammen hängen.

{| class="wikitable"
|-
| '''GIMSK'''
| '''G'''eneral '''I'''nterrupt '''M'''ask '''R'''egister. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6|| 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INT1''' || '''INT0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INT1''' (External '''Int'''errupt Request '''1''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT1'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

'''INT0''' (External '''Int'''errupt Request '''0''' Enable)
:Wenn dieses Bit gesetzt ist, wird ein Interrupt ausgelöst, wenn am '''INT0'''-Pin eine steigende oder fallende (je nach Konfiguration im '''MCUCR''') Flanke erkannt wird.
:Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.
:Der Interrupt wird auch ausgelöst, wenn der Pin als Ausgang geschaltet ist. Auf diese Weise bietet sich die Möglichkeit, Software-Interrupts zu realisieren.

|-
| '''GIFR'''
| '''G'''eneral '''I'''nterrupt '''F'''lag '''R'''egister.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''INTF1''' || '''INTF0''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-''' || '''-'''
|-
! R/W
| R/W || R/W || R || R || R || R || R || R
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''INTF1''' (External '''Int'''errupt Flag '''1''')
:Dieses Bit wird gesetzt, wenn am '''INT1'''-Pin eine Interrupt-Bedingung, entsprechend der Konfiguration, als eingetreten erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.

'''INTF0''' (External '''Int'''errupt Flag '''0''')
:Dieses Bit wird gesetzt, wenn am '''INT0'''-Pin eine Interrupt-Bedingung, entsprechend der Konfiguration, als eingetreten erkannt wird. Wenn das Global Enable Interrupt Flag gesetzt ist, wird die Interruptroutine angesprungen.
:Das Flag wird automatisch gelöscht, wenn die Interruptroutine beendet ist. Alternativ kann das Flag gelöscht werden, indem der Wert '''1(!)''' eingeschrieben wird.
|-
| '''MCUCR'''
| '''MCU''' '''C'''ontrol '''R'''egister.

Das MCU Control Register enthält Kontrollbits für allgemeine MCU-Funktionen.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''-'''|| '''-'''|| '''SE'''|| '''SM'''|| '''ISC11'''|| '''ISC10'''|| '''ISC01'''|| '''ISC00'''
|-
! R/W
| R || R || R/W || R/W || R/W || R/W || R/W || R/W
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0

|}

'''SE''' ('''S'''leep '''E'''nable)
:Dieses Bit muss gesetzt sein, um den Controller mit dem '''SLEEP'''-Befehl in den Schlafzustand versetzen zu können.
:Um den Schlafmodus nicht irrtümlich einzuschalten, wird empfohlen, das Bit erst unmittelbar vor Ausführung des '''SLEEP'''-Befehls zu setzen.

'''SM''' ('''S'''leep '''M'''ode)
:Dieses Bit bestimmt über den Schlafmodus.
:Ist das Bit gelöscht, so wird der '''Idle'''-Modus ausgeführt. Ist das Bit gesetzt, so wird der '''Power-Down'''-Modus ausgeführt. (für andere AVR Controller siehe Abschnitt "Sleep-Mode")

'''ISC11''', '''ISC10''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''1''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT1'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC11 || ISC10 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT1''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT1''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT1''' erzeugt einen Interrupt.
|}

'''ISC01''', '''ISC00''' ('''I'''nterrupt '''S'''ense '''C'''ontrol '''0''' Bits)
:Diese beiden Bits bestimmen, ob die steigende oder die fallende Flanke für die Interrupterkennung am '''INT0'''-Pin ausgewertet wird.

:{| class="wikitable"
|-
! ISC01 || ISC00 || Bedeutung
|-
| align="center" | 0
| align="center" | 0
| Low Level an '''INT0''' erzeugt einen Interrupt.

Der Interrupt wird getriggert, solange der Pin auf 0 bleibt.
|-
| align="center" | 0
| align="center" | 1
| Reserviert
|-
| align="center" | 1
| align="center" | 0
| Die fallende Flanke an '''INT0''' erzeugt einen Interrupt.
|-
| align="center" | 1
| align="center" | 1
| Die steigende Flanke an '''INT0''' erzeugt einen Interrupt.
|}

|}

== Allgemeines über die Interrupt-Abarbeitung ==

Wenn ein Interrupt eintrifft, wird automatisch das '''Global Interrupt Enable''' Bit im Status Register '''SREG''' gelöscht und alle weiteren Interrupts unterbunden. Obwohl es möglich ist, zu diesem Zeitpunkt bereits wieder das GIE-bit zu setzen, wird dringend davon abgeraten. Dieses wird nämlich automatisch gesetzt, wenn die Interruptroutine beendet wird. Wenn in der Zwischenzeit weitere Interrupts eintreffen, werden die zugehörigen Interrupt-Bits gesetzt und die Interrupts bei Beendigung der laufenden Interrupt-Routine in der Reihenfolge ihrer Priorität ausgeführt. Dies kann
eigentlich nur dann zu Problemen führen, wenn ein hoch priorisierter Interrupt ständig und in kurzer Folge auftritt. Dieser sperrt dann möglicherweise alle anderen Interrupts mit niedrigerer Priorität. Dies ist einer der Gründe, weshalb die Interrupt-Routinen sehr kurz gehalten werden sollen.



== Interrupts mit dem AVR GCC Compiler (WinAVR) ==


Funktionen zur Interrupt-Verarbeitung werden in den Includedateien ''interrupt.h'' der avr-libc zur Verfügung gestellt (bei älterem Quellcode zusätzlich ''signal.h'').

<c>
// fuer sei(), cli() und ISR():
#include <avr/interrupt.h>
</c>

Das Makro '''sei()''' schaltet die Interrupts ein. Eigentlich wird nichts anderes gemacht, als das '''Global Interrupt Enable''' Bit im Status Register gesetzt.

<c>
sei();
</c>

Das Makro '''cli()''' schaltet die Interrupts aus, oder anders gesagt, das '''Global Interrupt Enable''' Bit im Status Register wird gelöscht.

<c>
cli();
</c>

Oft steht man vor der Aufgabe, dass eine Codesequenz nicht unterbrochen werden darf. Es liegt dann nahe, zu Beginn dieser Sequenz ein cli() und am Ende ein sei() einzufügen. Dies ist jedoch ungünstig, wenn die Interrupts vor Aufruf der Sequenz deaktiviert waren und danach auch weiterhin deaktiviert bleiben sollen. Ein sei() würde ungeachtet des vorherigen Zustands die Interrupts aktivieren, was zu unerwünschten Seiteneffekten führen kann. Die aus dem folgenden Beispiel ersichtliche Vorgehensweise ist in solchen Fällen vorzuziehen:

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

//...

void NichtUnterbrechenBitte(void)
{
uint8_t tmp_sreg; // temporaerer Speicher fuer das Statusregister

tmp_sreg = SREG; // Statusregister (also auch das I-Flag darin) sichern
cli(); // Interrupts global deaktivieren

/* hier "unterbrechnungsfreier" Code */

/* Beispiel Anfang
JTAG-Interface eines ATmega16 per Software deaktivieren
und damit die JTAG-Pins an PORTC für "general I/O" nutzbar machen
ohne die JTAG-Fuse-Bit zu aendern. Dazu ist eine "timed sequence"
einzuhalten (vgl Datenblatt ATmega16, Stand 10/04, S. 229):
Das JTD-Bit muss zweimal innerhalb von 4 Taktzyklen geschrieben
werden. Ein Interrupt zwischen den beiden Schreibzugriffen wuerde
die erforderliche Sequenz "brechen", das JTAG-Interface bliebe
weiterhin aktiv und die IO-Pins weiterhin für JTAG reserviert. */

MCUCSR |= (1<<JTD);
MCUCSR |= (1<<JTD); // 2 mal in Folge ,vgl. Datenblatt fuer mehr Information

/* Beispiel Ende */

SREG = tmp_sreg; // Status-Register wieder herstellen
// somit auch das I-Flag auf gesicherten Zustand setzen
}

void NichtSoGut(void)
{
cli();

/* hier "unterbrechnungsfreier" Code */

sei();
}

int main(void)
{
//...

cli();
// Interrupts global deaktiviert

NichtUnterbrechenBitte();
// auch nach Aufruf der Funktion deaktiviert

sei();
// Interrupts global aktiviert

NichtUnterbrechenBitte();
// weiterhin aktiviert
//...

/* Verdeutlichung der unguenstigen Vorgehensweise mit cli/sei: */
cli();
// Interrupts jetzt global deaktiviert

NichtSoGut();
// nach Aufruf der Funktion sind Interrupts global aktiviert
// dies ist mglw. ungewollt!
//...

}
</c>


Zu den aktivierten Interrupts ist eine Funktion zu programmieren, deren Code aufgerufen wird, wenn der betreffende Interrupt auftritt (Interrupt-Handler, Interrupt-Service-Routine). Dazu existiert die Definition (ein Makro) '''ISR'''.

=== ISR ===

(''ISR()'' ersetzt bei neueren Versionen der avr-libc ''SIGNAL()''. SIGNAL sollte nicht mehr genutzt werden, zur Portierung von SIGNAL nach ISR siehe den [[AVR-GCC-Tutorial#Anhang|Anhang]].)

<c>
#include <avr/interrupt.h>
//...
ISR(Vectorname) /* vormals: SIGNAL(siglabel) dabei Vectorname != siglabel ! */
{
/* Interrupt Code */
}
</c>

Mit ''ISR'' wird eine Funktion für die Bearbeitung eines Interrupts eingeleitet. Als Argument muss dabei die Benennung des entsprechenden Interruptvektors angegeben werden. Diese sind in den jeweiligen Includedateien IOxxxx.h zu finden. Die Bezeichnung entspricht dem Namen aus dem Datenblatt, bei dem die Leerzeichen durch Unterstriche ersetzt sind und ein ''_vect'' angehängt ist.

Als Beispiel ein Ausschnitt aus der Datei für den ATmega8 (bei WinAVR Standardinstallation in C:\WinAVR\avr\include\avr\iom8.h) in der neben den aktuellen Namen für ''ISR'' (*_vect) noch die Bezeichnungen für das inzwischen nicht mehr aktuelle ''SIGNAL'' (SIG_*) enthalten sind.

<c>
//...
/* $Id: iom8.h,v 1.13 2005/10/30 22:11:23 joerg_wunsch Exp $ */

/* avr/iom8.h - definitions for ATmega8 */
//...

/* Interrupt vectors */

/* External Interrupt Request 0 */
#define INT0_vect _VECTOR(1)
#define SIG_INTERRUPT0 _VECTOR(1)

/* External Interrupt Request 1 */
#define INT1_vect _VECTOR(2)
#define SIG_INTERRUPT1 _VECTOR(2)

/* Timer/Counter2 Compare Match */
#define TIMER2_COMP_vect _VECTOR(3)
#define SIG_OUTPUT_COMPARE2 _VECTOR(3)

/* Timer/Counter2 Overflow */
#define TIMER2_OVF_vect _VECTOR(4)
#define SIG_OVERFLOW2 _VECTOR(4)

/* Timer/Counter1 Capture Event */
#define TIMER1_CAPT_vect _VECTOR(5)
#define SIG_INPUT_CAPTURE1 _VECTOR(5)

/* Timer/Counter1 Compare Match A */
#define TIMER1_COMPA_vect _VECTOR(6)
#define SIG_OUTPUT_COMPARE1A _VECTOR(6)

/* Timer/Counter1 Compare Match B */
#define TIMER1_COMPB_vect _VECTOR(7)
#define SIG_OUTPUT_COMPARE1B _VECTOR(7)

//...
</c>


Mögliche Funktionsrümpfe für Interruptfunktionen sind zum Beispiel:

<c>
#include <avr/interrupt.h>
/* veraltet: #include <avr/signal.h> */

ISR(INT0_vect) /* veraltet: SIGNAL(SIG_INTERRUPT0) */
{
/* Interrupt Code */
}

ISR(TIMER0_OVF_vect) /* veraltet: SIGNAL(SIG_OVERFLOW0) */
{
/* Interrupt Code */
}

ISR(USART_RXC_vect) /* veraltet: SIGNAL(SIG_UART_RECV) */
{
/* Interrupt Code */
}

// und so weiter und so fort...
</c>

Auf die korrekte Schreibweise der Vektorbezeichnung ist zu achten. Der gcc-Compiler prüft erst ab Version 4.x, ob ein Signal/Interrupt der angegebenen Bezeichnung tatsächlich in der Includedatei definiert ist und gibt andernfalls eine Warnung aus. Bei WinAVR (ab 2/2005) wurde die Überprüfung auch in den mitgelieferten Compiler der Version 3.x integriert. Aus dem gcc-Quellcode Version 3.x selbst erstellte Compiler enthalten die Prüfung nicht (vgl. [[AVR-GCC]]).

Während der Ausführung der Funktion sind alle weiteren Interrupts automatisch gesperrt. Beim Verlassen der Funktion werden die Interrupts wieder zugelassen.

Sollte während der Abarbeitung der Interruptroutine ein weiterer Interrupt (gleiche oder andere Interruptquelle) auftreten, so wird das entsprechende Bit im zugeordneten Interrupt Flag Register gesetzt und die entsprechende Interruptroutine automatisch nach dem Beenden der aktuellen Funktion aufgerufen.

Ein Problem ergibt sich eigentlich nur dann, wenn während der Abarbeitung der aktuellen Interruptroutine mehrere gleichartige Interrupts auftreten. Die entsprechende Interruptroutine wird im Nachhinein zwar aufgerufen jedoch wissen wir nicht, ob nun der entsprechende Interrupt einmal, zweimal oder gar noch öfter aufgetreten ist. Deshalb soll hier noch einmal betont werden, dass Interruptroutinen so schnell wie nur irgend möglich wieder verlassen werden sollten.

=== Unterbrechbare Interruptroutinen ===

"Faustregel": im Zweifel '''ISR'''. Die nachfolgend beschriebene Methode nur dann verwenden, wenn man sich über die unterschiedliche Funktionsweise im Klaren ist.

<c>
#include <avr/interrupt.h>

ISR(XXX,ISR_NOBLOCK) /* veraltet: INTERRUPT(SIG_OVERFLOW0) */
{
/* Interrupt-Code */
}
</c>

Hierbei steht XXX für den oben beschriebenen Namen des Vektors (also z. B. ''TIMER0_OVF_vect''). Der Unterschied im Vergleich zu einer herkömmlichen ISR ist, dass hier beim Aufrufen der Funktion das '''Global Enable Interrupt''' Bit durch Einfügen einer SEI-Anweisung direkt wieder gesetzt und somit alle Interrupts zugelassen werden – auch XXX-Interrupts.

Bei unsachgemässer Handhabung kann dies zu erheblichen Problemen wie einem Stack-Overflow oder anderen unerwarteten Effekten führen und sollte wirklich nur dann eingesetzt werden, wenn man sich sicher ist, das Ganze auch im Griff zu haben.

Insbesondere sollte möglichst am ISR-Anfang die auslösende IRQ-Quelle deaktiviert und erst am Ende der ISR wieder aktiviert werden. Robuster als die Verwendung einer NOBLOCK-ISR ist daher folgender ISR-Aufbau:

<c>
#include <avr/interrupt.h>

ISR (XXX)
{
// Implementiere die ISR ohne zunaechst weitere IRQs zuzulassen

<<Dektiviere die XXX-IRQ>>

// Erlaube alle Interrupts (ausser XXX)
sei();

//... Code ...

// IRQs global deaktivieren um die XXX-IRQ wieder gefahrlos
// aktivieren zu koennen
cli();

<<Aktiviere die XXX-IRQ>>
}
</c>
Auf diese Weise kann sich die XXX-IRQ nicht selbst unterbrechen, was zu einer Art Endlosschleife führen würde.

Siehe auch: Hinweise in [[AVR-GCC]]

siehe dazu: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

== Datenaustausch mit Interrupt-Routinen ==

Variablen, die sowohl in Interrupt-Routinen (ISR = Interrupt Service Routine(s)) als auch vom übrigen Programmcode geschrieben oder gelesen werden, müssen mit einem '''volatile''' deklariert werden. Damit wird dem Compiler mitgeteilt, dass der Inhalt der Variablen vor jedem Lesezugriff aus dem Speicher gelesen und nach jedem Schreibzugriff in den Speicher geschrieben wird. Ansonsten könnte der Compiler den Code so optimieren, dass der Wert der Variablen nur in Prozessorregistern zwischengespeichert wird, die nichts von der Änderung woanders mitbekommen.

Zur Veranschaulichung ein Codefragment für eine Tastenentprellung mit Erkennung einer "lange gedrückten" Taste.

<c>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
//...

// Schwellwerte
// Entprellung:
#define CNTDEBOUNCE 10
// "lange gedrueckt:"
#define CNTREPEAT 200

// hier z. B. Taste an Pin2 PortA "active low" = 0 wenn gedrueckt
#define KEY_PIN PINA
#define KEY_PINNO PA2

// beachte: volatile!
volatile uint8_t gKeyCounter;

// Timer-Compare Interrupt ISR, wird z.B. alle 10ms ausgefuehrt
ISR(TIMER1_COMPA_vect)
{
// hier wird gKeyCounter veraendert. Die übrigen
// Programmteile müssen diese Aenderung "sehen":
// volatile -> aktuellen Wert immer in den Speicher schreiben
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
}
else {
gKeyCounter = 0;
}
}

//...

int main(void)
{
//...
/* hier: Initialisierung der Ports und des Timer-Interrupts */
//...
// hier wird auf gKeyCounter zugegriffen. Dazu muss der in der
// ISR geschriebene Wert bekannt sein:
// volatile -> aktuellen Wert immer aus dem Speicher lesen
if ( gKeyCounter > CNTDEBOUNCE ) { // Taste mind. 10*10 ms "prellfrei"
if (gKeyCounter == CNTREPEAT) {
/* hier: Code fuer "Taste lange gedrueckt" */
}
else {
/* hier: Code fuer "Taste kurz gedrueckt" */
}
}
//...
}
</c>

Wird innerhalb einer ISR mehrfach auf eine mit volatile deklarierte Variable zugegriffen, wirkt sich dies ungünstig auf die Verarbeitungsgeschwindigkeit aus, da bei jedem Zugriff mit dem Speicherinhalt abgeglichen wird. Da bei AVR-Controllern ''innerhalb'' einer ISR keine Unterbrechungen zu erwarten sind, bietet es sich an, einen Zwischenspeicher in Form einer lokalen Variable zu verwenden, deren Inhalt zu Beginn und am Ende mit dem der volatile Variable synchronisiert wird. Lokale Variable werden bei eingeschalteter Optimierung mit hoher Wahrscheinlichkeit in Prozessorregistern verwaltet und der Zugriff darauf ist daher nur mit wenigen internen Operationen verbunden. Die ISR aus dem vorherigen Beispiel lässt sich so optimieren:

<c>
//...
ISR(TIMER1_COMPA_vect)
{
uint8_t tmp_kc;

tmp_kc = gKeyCounter; // Uebernahme in lokale Arbeitsvariable

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
if (tmp_kc < CNTREPEAT) {
tmp_kc++;
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc; // Zurueckschreiben
}
//...
</c>

Zum Vergleich die Disassemblies (Ausschnitte der "lss-Dateien", compiliert für ATmega162) im Anschluss. Man erkennt den viermaligen Zugriff auf die Speicheraddresse von ''gKeyCounter'' (hier 0x032A) in der ISR ohne "Cache"-Variable und den zweimaligen Zugriff in der Variante mit Zwischenspeicher. Im Beispiel ist der Vorteil gering, bei komplexeren Routinen kann die Zwischenspeicherung in lokalen Variablen jedoch zu deutlicheren Verbesserungen führen.

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
876: ca 99 sbic 0x19, 2 ; 25
878: 0a c0 rjmp .+20 ; 0x88e <__vector_13+0x24>
if (gKeyCounter < CNTREPEAT) gKeyCounter++;
87a: 80 91 2a 03 lds r24, 0x032A
87e: 88 3c cpi r24, 0xC8 ; 200
880: 40 f4 brcc .+16 ; 0x892 <__vector_13+0x28>
882: 80 91 2a 03 lds r24, 0x032A
886: 8f 5f subi r24, 0xFF ; 255
888: 80 93 2a 03 sts 0x032A, r24
88c: 02 c0 rjmp .+4 ; 0x892 <__vector_13+0x28>
}
else {
gKeyCounter = 0;
88e: 10 92 2a 03 sts 0x032A, r1
892: 8f 91 pop r24
894: 0f 90 pop r0
896: 0f be out 0x3f, r0 ; 63
898: 0f 90 pop r0
89a: 1f 90 pop r1
89c: 18 95 reti
</pre>

<pre>
ISR(TIMER1_COMPA_vect)
{
86a: 1f 92 push r1
86c: 0f 92 push r0
86e: 0f b6 in r0, 0x3f ; 63
870: 0f 92 push r0
872: 11 24 eor r1, r1
874: 8f 93 push r24
uint8_t tmp_kc;

tmp_kc = gKeyCounter;
876: 80 91 2a 03 lds r24, 0x032A

if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
87a: ca 9b sbis 0x19, 2 ; 25
87c: 02 c0 rjmp .+4 ; 0x882 <__vector_13+0x18>
87e: 80 e0 ldi r24, 0x00 ; 0
880: 03 c0 rjmp .+6 ; 0x888 <__vector_13+0x1e>
if (tmp_kc < CNTREPEAT) {
882: 88 3c cpi r24, 0xC8 ; 200
884: 08 f4 brcc .+2 ; 0x888 <__vector_13+0x1e>
tmp_kc++;
886: 8f 5f subi r24, 0xFF ; 255
}
}
else {
tmp_kc = 0;
}

gKeyCounter = tmp_kc;
888: 80 93 2a 03 sts 0x032A, r24
88c: 8f 91 pop r24
88e: 0f 90 pop r0
890: 0f be out 0x3f, r0 ; 63
892: 0f 90 pop r0
894: 1f 90 pop r1
896: 18 95 reti
</pre>

=== volatile und Pointer ===

Bei '''volatile''' in Verbindung mit Pointern ist zu beachten, ob der Pointer selbst oder die Variable, auf die der Pointer zeigt, '''volatile''' ist.

<c>
volatile uint8_t *a; // das Ziel von a ist volatile

uint8_t *volatile a; // a selbst ist volatile
</c>

Falls der Pointer volatile ist (zweiter Fall im Beispiel), ist zu beachten, dass der Wert des Pointers, also eine Speicheradresse, intern in mehr als einem Byte verwaltet wird. Lese- und Schreibzugriffe im Hauptprogramm (außerhalb von Interrupt-Routinen) sind daher so zu implementieren, dass alle Teilbytes der Adresse konsistent bleiben, vgl. dazu den folgenden Abschnitt.

=== Variablen größer 1 Byte ===

Bei Variablen größer ein Byte, auf die in Interrupt-Routinen und im Hauptprogramm zugegriffen wird, muss darauf geachtet werden, dass die Zugriffe auf die einzelnen Bytes außerhalb der ISR nicht durch einen Interrupt unterbrochen werden. (Allgemeinplatz: AVRs sind 8-bit Controller). Zur Veranschaulichung ein Codefragment:

<c>
//...
volatile uint16_t gMyCounter16bit;
//...
ISR(...)
{
//...
gMyCounter16Bit++;
//...
}

int main(void)
{
uint16_t tmpCnt;
//...
// nicht gut: Mglw. hier ein Fehler, wenn ein Byte von MyCounter
// schon in tmpCnt kopiert ist aber vor dem Kopieren des zweiten Bytes
// ein Interrupt auftritt, der den Inhalt von MyCounter verändert.
tmpCnt = gMyCounter16bit;

// besser: Änderungen "außerhalb" verhindern -> alle "Teilbytes"
// bleiben konsistent
cli(); // Interrupts deaktivieren
tmpCnt = gMyCounter16Bit;
sei(); // wieder aktivieren

// oder: vorheriger Status des globalen Interrupt-Flags bleibt erhalten
uint8_t sreg_tmp;
sreg_tmp = SREG; /* Sichern */
cli()
tmpCnt = gMyCounter16Bit;
SREG = sreg_tmp; /* Wiederherstellen */

// oder: mehrfach lesen, bis man konsistente Daten hat
uint16_t count1 = gMyCounter16Bit;
uint16_t count2 = gMyCounter16Bit;
while (count1 != count2) {
count1 = count2;
count2 = gMyCounter16Bit;
}
tmpCnt = count1;
//...
}
</c>

Die avr-libc bietet ab Version 1.6.0(?) einige Hilfsfunktionen/Makros, mit der im Beispiel oben gezeigten Funktionalität, die zusätzlich auch sogenannte [http://en.wikipedia.org/wiki/Memory_barrier memory barriers] beinhalten. Diese stehen nach #include <util/atomic.h> zur Verfügung.
<c>
//...
#include <util/atomic.h>
//...

// analog zu cli, Zugriff, sei:
ATOMIC_BLOCK(ATOMIC_FORCEON) {
tmpCnt = gMyCounter16Bit;
}

// oder:

// analog zu Sicherung des SREG, cli, Zugriff und Zurückschreiben des SREG:
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
tmpCnt = gMyCounter16Bit;
}

//...
</c>

* siehe auch [http://www.nongnu.org/avr-libc/user-manual/group__util__atomic.html Dokumentation der avr-libc zu atomic.h]

== Interrupt-Routinen und Registerzugriffe ==

Falls Register sowohl im Hauptprogramm als auch in Interrupt-Routinen verändert werden, ist darauf zu achten, dass diese Zugriffe sich nicht überlappen. Nur wenige Anweisungen lassen sich in sogenannte "atomare" Zugriffe übersetzen, die nicht von Interrupt-Routinen unterbrochen werden können.

Zur Veranschaulichung eine Anweisung, bei der ein Bit und im Anschluss drei Bits in einem Register gesetzt werden:

<c>
#include <avr/io.h>

int main(void)
{
//...
PORTA |= (1<<PA0);

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
//...
}
</c>

Der Compiler übersetzt diese Anweisungen für einen ATmega128 bei Optimierungsstufe "S" nach:

<div class="code"><pre>
...
PORTA |= (1<<PA0);
d2: d8 9a sbi 0x1b, 0 ; 27 (a)

PORTA |= (1<<PA2)|(1<<PA3)|(1<<PA4);
d4: 8b b3 in r24, 0x1b ; 27 (b)
d6: 8c 61 ori r24, 0x1C ; 28 (c)
d8: 8b bb out 0x1b, r24 ; 27 (d)
...
</pre></div>

Das Setzen des einzelnen Bits wird bei eingeschalteter Optimierung für Register im unteren Speicherbereich in eine einzige Assembler-Anweisung (sbi) übersetzt und ist nicht anfällig für Unterbrechungen durch Interrupts. Die Anweisung zum Setzen von drei Bits wird jedoch in drei abhängige Assembler-Anweisungen übersetzt und bietet damit zwei "Angriffspunkte" für Unterbrechungen. Eine Interrupt-Routine könnte nach dem Laden des Ausgangszustands in den Zwischenspeicher (hier Register 24) den Wert des Registers ändern, z. B. ein Bit löschen. Damit würde der Zwischenspeicher nicht mehr mit dem tatsächlichen Zustand übereinstimmen aber dennoch nach der Bitoperation (hier ori) in das Register zurückgeschrieben.

Beispiel: PORTA sei anfangs 0b00000000. Die erste Anweisung (a) setzt Bit 0, PORTA ist danach 0b00000001. Nun wird im ersten Teil der zweiten Anweisung der Portzustand in ein Register eingelesen (b). Unmittelbar darauf (vor (c)) "feuert" ein Interrupt, in dessen Interrupt-Routine Bit 0 von PORTA gelöscht wird. Nach Verlassen der Interrupt-Routine hat PORTA den Wert 0b00000000. In den beiden noch folgenden Anweisungen des Hauptprogramms wird nun der zwischengespeicherte "alte" Zustand 0b00000001 mit 0b00011100 logisch-oder-verknüft (c) und das Ergebnis 0b00011101 in PortA geschrieben (d). Obwohl zwischenzeitlich Bit 0 gelöscht wurde, ist es nach (d) wieder gesetzt.

Lösungsmöglichkeiten:
* Register ohne besondere Vorkehrungen nicht in Interruptroutinen ''und'' im Hauptprogramm verändern.
* Interrupts vor Veränderungen in Registern, die auch in ISRs verändert werden, deaktivieren ("cli").
* Bits einzeln löschen oder setzen. sbi und cbi können nicht unterbrochen werden. Vorsicht: nur Register im unteren Speicherbereich sind mittels sbi/cbi ansprechbar. Der Compiler kann nur für diese sbi/cbi-Anweisungen generieren. Für Register außerhalb dieses Adressbereichs ("Memory-Mapped"-Register) werden auch zur Manipulation einzelner Bits abhängige Anweisungen erzeugt (lds,...,sts).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Frequently asked Questions/Fragen Nr. 1 und 8. (Stand: avr-libc Vers. 1.0.4)

== Interruptflags löschen ==

Beim Löschen von Interruptflags haben AVRs eine Besonderheit, die auch im Datenblatt beschrieben ist: Es wird zum Löschen eine 1 in das betreffende Bit geschrieben.

Hinweis: Dazu '''nicht''' übliche bitweise VerODERung nehmen, sondern eine direkte Zuweisung machen ([http://www.mikrocontroller.net/topic/171148#1640133 Erklärung]).

== Was macht das Hauptprogramm? ==

Im einfachsten (Ausnahme-)Fall gar nichts mehr. Es ist also durchaus denkbar, ein Programm zu schreiben, welches in der main-Funktion lediglich noch die Interrupts aktiviert und dann in einer Endlosschleife verharrt. Sämtliche Funktionen werden dann in den ISRs abgearbeitet. Diese Vorgehensweise ist jedoch bei den meisten Anwendungen schlecht: man verschenkt eine Verarbeitungsebene und hat außerdem möglicherweise Probleme durch Interruptroutinen, die zu viel Verarbeitungszeit benötigen.

Normalerweise wird man in den Interruptroutinen nur die bei Auftreten des jeweiligen Interruptereignisses unbedingt notwendigen Operationen ausführen lassen. Alle weniger kritischen Aufgaben werden dann im Hauptprogramm abgearbeitet.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Interrupts and Signals

= Sleep-Modes =

AVR Controller verfügen über eine Reihe von sogenannten [[Sleep Mode |''Sleep-Modes'']] ("Schlaf-Modi"). Diese ermöglichen es, Teile des Controllers abzuschalten. Zum Einen kann damit besonders bei Batteriebetrieb Strom gespart werden, zum Anderen können Komponenten des Controllers deaktiviert werden, die die Genauigkeit des Analog-Digital-Wandlers bzw. des Analog-Comparators negativ beeinflussen. Der Controller wird durch Interrupts aus dem Schlaf geweckt. Welche Interrupts den jeweiligen Schlafmodus beenden, ist einer Tabelle im Datenblatt des jeweiligen Controllers zu entnehmen.
Die Funktionen (eigentlich Makros) der avr-libc stehen nach Einbinden der header-Datei ''sleep.h'' zur Verfügung.

;set_sleep_mode (uint8_t mode): Setzt den Schlafmodus, der bei Aufruf von sleep() aktiviert wird. In sleep.h sind einige Konstanten definiert (z. B. SLEEP_MODE_PWR_DOWN). Die definierten Modi werden jedoch nicht alle von sämtlichten AVR-Controllern unterstützt.
;sleep_enable(): Aktiviert den gesetzten Schlafmodus, versetzt den Controller aber noch nicht in den Schlafmodus
;sleep_cpu(): Versetzt den Controller in den Schlafmodus .sleep_cpu wird im Prinzip durch die Assembler-Anweisung ''sleep'' ersetzt.
;sleep_disable(): Deaktiviert den gesetzten Schlafmodus
;sleep_mode(): Versetzt den Controller in den mit set_sleep_mode gewählten Schlafmodus. Das Makro entspricht sleep_enable()+sleep_cpu()+sleep_disable(), beinhaltet also nicht die Aktivierung von Interrupts (besser nicht benutzen).

Bei Anwendung von sleep_cpu() müssen Interrupts also bereits freigeben sein (sei()), da der Controller sonst nicht mehr "aufwachen" kann. sleep_mode() ist nicht geeignet für die Verwendung in ISR Interrupt-Service-Routinen, da bei deren Abarbeitung Interrupts global deaktiviert sind und somit auch die möglichen "Aufwachinterrupts". Abhilfe: stattdessen sleep_enable(), sei(), sleep_cpu(), sleep_disable() und evtl. cli() verwenden (vgl. Dokumentation der avr-libc).

<c>
#include <avr/io.h>
#include <avr/sleep.h>

int main(void)
{
...

while (1) {
...
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

// Code hier wird erst nach Auftreten eines entsprechenden
// "Aufwach-Interrupts" verarbeitet
...
}
}
</c>

In älteren Versionenen der avr-libc wurden nicht alle AVR-Controller durch die sleep-Funktionen richtig angesteuert. Mit avr-libc 1.2.0 wurde die Anzahl der unterstützten Typen jedoch deutlich erweitert. Bei nicht-unterstützten Typen erreicht man die gewünschte Funktionalität durch direkte "[[Bitmanipulation]]" der entsprechenden Register (vgl. Datenblatt) und Aufruf des Sleep-Befehls via Inline-Assembler oder sleep_cpu():

<c>
#include <avr/io.h>
...
// Sleep-Mode "Power-Save" beim ATmega169 "manuell" aktivieren
SMCR = (3<<SM0) | (1<<SE);
asm volatile ("sleep"::); // alternativ sleep_cpu() aus sleep.h
...
</c>

== Sleep Modi ==
Zu beachten ist, dass unterschiedliche Prozessoren aus der AVR Familie unterschiedliche Sleep-Modi unterstützen oder nicht unterstützen. Auskunft über die tatsächlichen Gegebenheiten gibt, wie immer, das zum Prozessor gehörende Datenblatt. Die unterschiedlichen Modi unterscheiden sich dadurch, welche Bereiche des Prozessors abgeschaltet werden. Damit korrespondiert unmittelbar welche Möglichkeiten es gibt, den Prozessor aus den jeweiligen Sleep Modus wieder aufzuwecken.

;Idle Mode (SLEEP_MODE_IDLE): Die CPU kann durch SPI, USART, Analog Comperator, ADC, TWI, Timer, Watchdog und irgendeinen anderen Interrupt wieder aufgeweckt werden.

;ADC Noise Reduction Mode (SLEEP_MODE_ADC): In diesem Modus liegt das Hauptaugenmerk darauf, die CPU soweit stillzulegen, dass der ADC möglichst keine Störungen aus dem inneren der CPU auffangen kann. Aufwachen aus diesem Modus kann ausgelöst werden durch den ADC, externe Interrupts, TWI, Timer und Watchdog.

;Power-Down Mode (SLEEP_MODE_PWR_DOWN): In diesem Modus wird ein externer Oszillator (Quarz, Quarzoszillator) gestoppt. Geweckt werden kann die CPU durch einen externen Level Interrupt, TWI, Watchdog, Brown-Out-Reset

;Power-Save-Mode (SLEEP_MODE_PWR_SAVE): Power-Save ist identisch zu Power-Down mit einer Ausnahme: Ist der Timer 2 auf die Verwendung eines externen Taktes konfiguriert, so läuft dieser Timer auch im Power-Save weiter und kann die CPU mit einem Interrupt aufwecken.

;Standby-Mode (SLEEP_MODE_STANDBY, SLEEP_MODE_EXT_STANDBY): Voraussetzung für den Standby-Modus ist die Verwendung eines Quarzes oder eines Quarzoszillators (also einer externen Taktquelle). Ansonsten ist dieser Modus identisch zum Power-Down Modus. Vorteil dieses Modus ist eine kürzere Aufwachzeit.

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/Power Management and Sleep-Modes
* [http://www.mikrocontroller.net/topic/96369#832712 Forenbeitrag] zur "Nichtverwendung" von sleep_mode in ISRs.

= Zeiger =
Zeiger (engl. ''Pointer'') sind Variablen, die die Adresse von Daten oder Funktionen enthalten und belegen 16 Bits. Die Größe hängt mit dem adressierbaren Speicherbereich zusammen und der GCC reserviert dann den entsprechenden Platz.
Ggf. ist es also günstiger, Indizes auf Arrays (Listen) zu verwenden, so dass der GCC für die Zeigerarithmetik den erforderlichen RAM nur temporär benötigt.

Siehe auch: [[Zeiger]]

= Speicherzugriffe =

Atmel AVR-Controller verfügen typisch über drei Speicher:

* [[RAM]]: Im RAM (genauer statisches RAM/SRAM) wird vom gcc-Compiler Platz für Variablen reserviert. Auch der Stack befindet sich im RAM. Dieser Speicher ist "flüchtig", d.h. der Inhalt der Variablen geht beim Ausschalten oder einem Zusammenbruch der Spannungsversorgung verloren.

* Programmspeicher: Ausgeführt als FLASH-Speicher, seitenweise wiederbeschreibbar. Darin ist das Anwendungsprogramm abgelegt.

* [[EEPROM]]: Nichtflüchtiger Speicher, d.h. der einmal geschriebene Inhalt bleibt auch ohne Stromversorgung erhalten. Byte-weise schreib/lesbar. Im EEPROM werden typischerweise gerätespezifische Werte wie z. B. Kalibrierungswerte von Sensoren abgelegt.

Einige AVRs besitzen keinen RAM-Speicher, lediglich die Register können als "Arbeitsvariablen"
genutzt werden. Da die Anwendung des avr-gcc auf solch "kleinen" Controllern ohnehin selten sinnvoll ist und auch nur bei einigen RAM-losen Typen nach [http://lightner.net/avr/ATtinyAvrGcc.html "Bastelarbeiten"] möglich ist, werden diese Controller hier nicht weiter berücksichtigt. Auch EEPROM-Speicher ist nicht auf allen Typen verfügbar. Generell sollten die nachfolgenden Erläuterungen auf alle ATmega-Controller und die größeren AT90-Typen übertragbar sein. Für die Typen ATtiny2313, ATtiny26 und viele weitere der "ATtiny-Reihe" gelten die Ausführungen ebenfalls.

Siehe auch:
* [[Binäre Daten zum Programm hinzufügen]]
== RAM ==

Die Verwaltung des RAM-Speichers erfolgt durch den Compiler, im Regelfall ist beim Zugriff auf Variablen im RAM nichts Besonderes zu beachten. Die Erläuterungen in jedem brauchbaren C-Buch gelten auch für den vom avr-gcc-Compiler erzeugten Code.

Um Speicher dynamisch (während der Laufzeit) zu reservieren, kann '''malloc()''' verwendet werden. malloc(size) "alloziert" (~reserviert) einen gewissen Speicherblock mit '''size''' Bytes. Ist kein Platz für den neuen Block, wird NULL (0) zurückgegeben.

Wird der angelegte Block zu klein (groß), kann die Größe mit realloc() verändert werden. Den allozierten Speicherbereich kann man mit free() wieder freigeben. Wenn das Freigeben eines Blocks vergessen wird spricht man von einem "Speicherleck" (memory leak).

malloc() legt Speicherblöcke im '''Heap''' an, belegt man zuviel Platz, dann wächst der Heap zu weit nach oben und überschreibt den Stack, und der Controller kommt in Teufels Küche. Das kann leider nicht nur passieren wenn man insgesamt zu viel Speicher anfordert, sondern auch wenn man Blöcke unterschiedlicher Größe in ungünstiger Reihenfolge alloziert/freigibt (siehe Artikel [[Heap-Fragmentierung]]). Aus diesem Grund sollte man malloc() auf Mikrocontrollern sehr sparsam (am besten gar nicht) verwenden.

Beispiel zur Verwendung von malloc():
<c>
#include <stdlib.h>

void foo(void) {
// neuen speicherbereich anlegen,
// platz für 10 uint16
uint16_t* pBuffer = malloc(10 * sizeof(uint16_t));

// darauf zugreifen, als wärs ein gewohnter Buffer
pBuffer[2] = 5;

// Speicher (unbedingt!) wieder freigeben
free(pBuffer);
}
</c>

Wenn (wie in obigem Beispiel) dynamischer Speicher nur für die Dauer einer Funktion benötigt und am Ende wieder freigegeben wird, bietet es sich an, statt malloc() '''alloca()''' zu verwenden. Der Unterschied zu malloc() ist, dass der Speicher auf dem Stack reserviert wird, und beim Verlassen der Funktion automatisch wieder freigegeben wird. Es kann somit kein Speicherleck und keine Fragmentierung entstehen.

siehe auch:
* http://www.nongnu.org/avr-libc/user-manual/malloc.html

== Programmspeicher (Flash) ==

Ein Zugriff auf Konstanten im Programmspeicher ist mittels avr-gcc nicht "transparent" möglich. D.h. es sind besondere Zugriffsfunktionen erforderlich, um Daten aus diesem Speicher zu lesen. Grundsätzlich basieren alle Zugriffsfunktionen auf der Assembler-Anweisung lpm (load program memory, bei AVR Controllern mit mehr als 64kB Flash auch elpm). Die Standard-Laufzeitbibliothek des avr-gcc (die avr-libc) stellt diese Funktionen nach Einbinden der Header-Datei pgmspace.h zur Verfügung. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke gelesen werden.

Deklarationen von Variablen im Flash-Speicher werden durch das "Attribut" PROGMEM ergänzt. Lokale Variablen (eigentlich Konstanten) innerhalb von Funktionen können ebenfalls im Programmspeicher abgelegt werden. Dazu ist bei der Definition jedoch ein ''static'' voranzustellen, da solche "Variablen" nicht auf dem Stack bzw. (bei Optimierung) in Registern verwaltet werden können. Der Compiler "wirft" eine Warnung falls static fehlt.

<c>
#include <stdint.h>
#include <avr/pgmspace.h>

/* Byte */
const uint8_t pgmFooByte PROGMEM = 123;

/* Wort */
const uint16_t pgmFooWort PROGMEM = 12345;

/* Byte-Array */
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3 ,70 };
const uint8_t pgmFooByteArray2[] PROGMEM = { 30, 7 ,79 };

/* Zeiger */
const uint8_t * const pgmPointerToArray1 PROGMEM = pgmFooByteArray1;
const uint8_t * const pgmPointerArray[] PROGMEM = { pgmFooByteArray1, pgmFooByteArray2 };

void foo(void)
{
static const uint8_t pgmTestByteLocal PROGMEM = 0x55;
static const char pgmTestStringLocal[] PROGMEM = "im Flash";
// so nicht (static fehlt)
// char pgmTestStringLocalFalsch [] PROGMEM = "so nicht";
}
</c>

=== Byte lesen ===

Mit der Funktion pgm_read_byte aus pgmspace.h erfolgt der Zugriff auf die Daten. Parameter der Funktion ist die Adresse des Bytes im Flash-Speicher.

<c>
#include <avr/pgmspace.h>

const uint8_t pgmFooByte PROGMEM = 123;
const uint8_t pgmFooByteArray1[] PROGMEM = { 18, 3, 70 };

void foo (void)
// Wert der Ram-Variablen myByte auf den Wert von pgmFooByte setzen:
uint8_t myByte;

myByte = pgm_read_byte (&pgmFooByte);
// myByte hat nun den Wert 123

// Schleife ueber ein Array aus Byte-Werten im Flash
uint8_t i;

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (&pgmFooByteArray1[i]);
// mach was mit myByte
}
</c>

=== Wort lesen ===

Für "einfache" 16-Bit breite Variablen erfolgt der Zugriff analog zum Byte-Beispiel, jedoch mit der Funktion <code>pgm_read_word</code>:

<c>
const uint16_t pgmFooWort PROGMEM = 12345;

uint16_t myWord = pgm_read_word (&pgmFooWort);
</c>

Zeiger auf Werte im Flash sind ebenfalls 16 Bits "groß".
Damit ist der mögliche Speicherbereich für "Flash-Konstanten" auf 64kB begrenzt.<ref>Einige avr-libc/pgmspace-Funktionen ermöglichen den Lesezugriff auf den gesamten Flash-Speicher, intern via Assembler Anweisung ELPM. Die Initialisierungswerte des Speicherinhalts jenseits der 64kB-Marke müssen dann jedoch auf anderem Weg angelegt werden, d.h. nicht per PROGMEM; evtl. eigene Section und Linker-Optionen. Alt und nicht ganz korrekt: Die avr-libc pgmspace-Funktionen unterstützen nur die unteren 64kB Flash bei Controllern mit mehr als 64kB.</ref>

<c>
const uint8_t *ptrToArray;

ptrToArray = (const uint8_t*) pgm_read_word (&pgmPointerToArray1);
// ptrToArray enthält nun die Startadresse des Byte-Arrays pgmFooByteArray1
// Allerdings würde ein direkter Zugriff mit diesem Pointer (z. B. temp=*ptrToArray)
// nicht den Inhalt von pgmFooByteArray1[0] liefern, sondern von einer Speicherstelle
// im RAM, die die gleiche Adresse hat wie pgmFooByteArray1[0]
// Daher muss nun die Funktion pgm_read_byte() benutzt werden, die die in ptrToArray
// enthaltene Adresse benutzt und auf das Flash zugreift.

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (ptrToArray+i);
// mach was mit myByte... (18, 3, 70)
}

ptrToArray = (const uint8_t*) pgm_read_word (&pgmPointerArray[1]);

// ptrToArray enthält nun die Adresse des ersten Elements des Byte-Arrays pgmFooByteArray2
// da im zweiten Element des Pointer-Arrays pgmPointerArray die Adresse
// von pgmFooByteArray2 abgelegt ist

for (i = 0; i < 3; i++)
{
myByte = pgm_read_byte (ptrToArray+i);
// mach was mit myByte... (30, 7, 79)
}
</c>

=== Block lesen ===
In den Standard-Flash Funktionen ist keine der pgm_read_xxxx Nomenklatur folgenden Funktion enthalten, die einen kompletten Block ausliest. Die enstprechende Funktion ist eine Variante von memcpy und heißt memcpy_P().

Was diese Funktion im Prinzip macht, ist einfach in einer Schleife pgm_read_byte zu benutzen, um einen Speicherblock von der Quelladresse im Flash an eine Zieladresse im SRAM zu kopieren.

<c>
void pgm_read_block( uint8_t* pTarget, const uint8_t* pSource, size_t len )
{
size_t i;

for( i = 0; i < len; ++i )
*pTarget++ = pgm_read_byte( pSource++ );
}
</c>

Damit ist es dann natürlich kein Problem mehr ganze Arrays oder Strukturen aus dem Flash in das SRAM zu übertragen.

=== Strings lesen ===
Strings sind in C nichts anderes als eine Abfolge von Zeichen. Der prinzipielle Weg ist daher identisch zu "Bytes lesen", wobei allerdings auf die [http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F Besonderheiten von Strings] wie 0-Terminierung geachtet werden muss, bzw. diese zur Steuerung einer Schleife über die Zeichen im String ausgenutzt werden kann

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hello world";

int main()
{
char c;
const char* addr;

addr = pgmString;
while (c = pgm_read_byte (addr++), c != '\0')
{
// mach was mit c
}
}
</c>

Zur Unterstützung des Programmierers steht das Repertoir der str-Funktionen auch in jeweils eine Variante zur Verfügung, die mit dem Flash-Speicher arbeiten kann. Die Funktionsnamen tragen den Suffix <tt>_P</tt>.

<c>
#include <avr/io.h>
#include <avr/pgmspace.h>

const char pgmString[] PROGMEM = "Hallo world";

void foo (void)
{
char string[40];

strcpy_P (string, pgmString);
}
</c>

=== Float lesen ===

Auch um floats zu lesen gibt es ein Makro:

<c>
float pgmFloatArray[3] PROGMEM = {1.1, 2.2, 3.3};

void read_float (void)
{
int i;
float f;

for (i=0; i<3; i++)
{
// entspricht f = pgmFloatArray[i];
f = pgm_read_float (&pgmFloatArray[i]);
// mach was mit f
}
}
</c>

TODO: Beispiele für structs und pointer aus Flash auf struct im Flash (menues, state-machines etc.). Eine kleine Einleitung insbesondere auch in Bezug auf die auftretenden Schwierigkeiten liefert [http://www.mail-archive.com/avr-gcc-list@nongnu.org/msg05652.html].

=== Array aus Strings im Flash-Speicher ===

Arrays aus Strings im Flash-Speicher werden in zwei Schritten angelegt: Zuerst die einzelnen Elemente des Arrays und im Anschluss ein Array, in dem die Startaddressen der Strings abgelegt werden. Zum Auslesen wird zuerst die Adresse des i-ten Elements aus dem Array im Flash-Speicher gelesen, die im Anschluss dazu genutzt wird, auf das Element (den String) selbst zuzugreifen.

<c>
#include <stdint.h>
#include <avr/pgmspace.h>

const char str1[] PROGMEM = "first_A";
const char str2[] PROGMEM = "second_A";
const char str3[] PROGMEM = "third_A";

const char * const strarray1[] PROGMEM =
{
str1,
str2,
str3
};

static char work[20];

void read_strings (void)
{
size_t i;

for (i = 0; i < sizeof (strarray1) / sizeof (strarray1[0]); i++)
{
size_t j, len;

// setze Pointer auf die Addresse des i-ten Elements des
// Flash-Arrays (str1, str2, ...)
const char *pstrflash = (const char*) pgm_read_word (&strarray1[i]);

// kopiere den Inhalt der Zeichenkette von der
// in pstrflash abgelegten Adresse in das work-Array
// analog zu strcpy( work, strarray1[i]) wenn alles im RAM
strcpy_P (work, pstrflash);

// Gleichbedeutend damit:
strcpy_P (work, (const char*) pgm_read_word (&strarray1[i]));

// Zeichen-fuer-Zeichen
len = strlen_P (&strarray1[i]);

// <= da auch das Stringende-Zeichen kopiert werden soll
for (j = 0; j <= len; j++)
{
// analog zu work[j] = strarray[i][j] wenn alles im RAM
work[i] = (char) pgm_read_byte (pstrflash++);
}
}
}
</c>

Siehe dazu auch die avr-libc FAQ: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_rom_array How do I put an array of strings completely in ROM?]

=== Vereinfachung für Zeichenketten (Strings) im Flash ===

Zeichenketten können innerhalb des Quellcodes als "Flash-Konstanten" ausgewiesen werden. Dazu dient das Makro PSTR aus pgmspace.h. Dies erspart die getrennte Deklaration mit PROGMEM-Attribut.

<c>
#include <string.h>
#include <avr/pgmspace.h>

#define MAXLEN 30

char StringImFlash[] PROGMEM = "Erwin Lindemann";
char StringImRam[MAXLEN];

void read_string (void)
{
strcpy (StringImRam, "Mueller-Luedenscheidt");

if (!strncmp_P (StringImRam, StringImFlash, 5))
{
// mach was, wenn die ersten 5 Zeichen identisch - hier nicht
}
else
{
// der Code hier wuerde ausgefuehrt
}

if (!strncmp_P (StringImRam, PSTR("Mueller-Schmitt"), 5))
{
// der Code hier wird ausgefuehrt, wenn die ersten
// 5 Zeichen uebereinstimmen
}
else
{
// wird bei Nicht-Uebereinstimmung ausgefuehrt
}
}
</c>

Aber Vorsicht: Ersetzt man zum Beispiel
<c>
// Daten im "Flash"
const char flashText[] PROGMEM = "mit[]";
</c>
durch
<c>
// Hier wird "mit*" im RAM angelegt und flashPointer
// enthaelt die Adresse
const char* const flashPointer PROGMEM = "mit*";
</c>
dann kann es zu Problemen kommen.

Übergibt man Zeichenketten, die im Flash abglegt sind an eine Funktion – also die Adresse des ersten Zeichens – so muss die Funktion entsprechend programmiert sein. Die Funktion selbst hat keine Möglichkeit zu unterscheiden, ob es sich um eine Flash-Adresse oder ein RAM-Adresse handelt. Die avr-libc und viele andere avr-gcc-Bibliotheken halten sich an die Konvention, dass Namen von Funktionen, die Flash-Adressen erwarten, mit dem Suffix <code>_P</code> versehen sind.

Eine Funktion, die einen im Flash abgelegten String z. B. an eine UART ausgibt, würde dann so aussehen:

<c>
void uart_puts_p (const char *text)
{
char zeichen;

while ((zeichen = pgm_read_byte (text)))
{
// so lange, wie mittels pgm_read_byte nicht das Stringende
// gelesen wurde: gib dieses Zeichen aus

uart_putc (Zeichen);
text++;
}
}
</c>

Von einigen Bibliotheken werden Makros definiert, die "automatisch" ein PSTR bei Verwendung einer Funktion einfügen. Ein Blick in den Header-File der Bibliothek zeigt, ob dies der Fall ist. Ein Beispiel aus P. Fleurys lcd-Library:

<c>
// Ausschnitt aus dem Header-File lcd.h der "Fleury-LCD-Lib."
extern void lcd_puts_p (const char *progmem_s);
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))

// in einer Anwendung
#include <avr/pgmspace.h>
#include <string.h>
#include "lcd.h"

const char StringImFlash[] PROGMEM = "Erwin Lindemann";

void my_write (coid)
{
lcd_puts_p (StringImFlash);
lcd_puts_P ("Dr. Kloebner");
}</c>

=== Flash in der Anwendung schreiben ===

Bei AVRs mit "self-programming"-Option – auch bekannt als [[Bootloader]]-Support – können Teile des Flash-Speichers vom Anwendungsprogramm beschrieben werden. Dies ist nur möglich, wenn die Schreibfunktion in einem besonderen Speicherbereich, der boot-section des Programmspeichers/Flash, abgelegt ist.

Bei einigen kleinen AVRs gibt es keine gesonderte Boot-Section, bei diesen kann der Flashspeicher von jeder Stelle des Programms geschrieben werden. Für Details sei hier auf das jeweilige Controller-Datenblatt und die Erläuterungen zum Modul boot.h der avr-libc verwiesen. Es existieren auch Application-Notes dazu bei atmel.com, die auf avr-gcc-Code übertragbar sind.

Siehe auch:
* Forumsbeitrag [http://www.mikrocontroller.net/topic/163632#1561622 Daten in Programmspeicher speichern]

=== Warum so kompliziert? ===

Zu dem Thema, warum die Verabeitung von Werten aus dem Flash-Speicher so kompliziert ist, sei hier nur kurz erläutert: Die Harvard-Architektur des AVR weist getrennte Adressräume für Programm(Flash)- und Datenspeicher(RAM) auf. Der C-Standard und der gcc-Compiler sehen keine unterschiedlichen Adressräume vor.

Hat man zum Beispiel eine Funktion string_an_uart(const char* s) und übergibt an diese Funktion die Adresse einer Zeichenkette, z. B. 0x01fe, weiß die Funktion nicht, ob die Adresse auf den Flash-Speicher oder den/das RAM zeigt. Allein aus dem Pointer-Wert, also dem Zahlenwert, kann nicht auf den Ort der Ablage geschlossen werden.

Einige AVR-Compiler bilden die Harvard-Architektur ab, indem sie in einen Pointer nicht nur die Adresse speichern, sondern auch den Ablageort wie ''Flash'' oder ''RAM''. In einem Aufruf einer Funktion wird dann bei Pointer-Parametern neben der Adresse auch der Speicherbereich, auf den der Pointer zeigt, übergeben. Dies hat jedoch auch Nachteile, denn bei jedem Zugriff über einen Zeiger muss zur ''Laufzeit'' entschieden werden, wie der Zugriff auszuführen ist und entsprechend länglicher und langsamer kann Code ausgeführt werden.

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitte Modules/Program Space String Utilities und Abschnitt Modules/Bootloader Support Utilities

== EEPROM ==

Man beachte, dass der EEPROM-Speicher nur eine begrenzte Anzahl von Schreibzugriffen zulässt. Beschreibt man eine EEPROM-Zelle öfter als die im Datenblatt zugesicherte Anzahl (typisch 100.000), wird die Funktion der Zelle nicht mehr garantiert.
Dies gilt für jede einzelne Zelle. Bei geschickter Programmierung (z. B. Ring-Puffer), bei der die zu beschreibenden Zellen regelmäßig gewechselt werden, kann man eine deutlich höhere Anzahl an Schreibzugriffen, bezogen auf den Gesamtspeicher, erreichen.

Schreib- und Lesezugriffe auf den EEPROM-Speicher erfolgen über die im Modul eeprom.h definierten Funktionen. Mit diesen Funktionen können einzelne Bytes, Datenworte (16bit) und Datenblöcke geschrieben und gelesen werden.

Bei Nutzung des EEPROMs ist zu beachten, dass vor dem Zugriff auf diesen Speicher abgefragt wird, ob der Controller die vorherige EEPROM-Operation abgeschlossen hat. Die avr-libc-Funktionen beinhalten diese Prüfung, man muss sie nicht selbst implementieren. Man sollte auch verhindern, dass der Zugriff durch die Abarbeitung einer Interrupt-Routine unterbrochen wird, da bestimme Befehlsabfolgen vorgegeben sind, die innerhalb weniger Taktzyklen aufeinanderfolgen müssen ("timed sequence"). Auch dies muss bei Nutzung der Funktionen aus der avr-libc/eeprom.h-Datei nicht selbst implementiert werden. Innerhalb der Funktionen werden Interrupts vor der "EEPROM-Sequenz" global deaktiviert und im Anschluss, falls vorher auch schon eingeschaltet, wieder aktiviert.

Um eine Variable im EEPROM anzulegen, stellt die avr-libc das Makro EEMEM zur Verfügung<ref>In älteren Versionen der avr-libc ist EEMEM noch nicht vorhanden, und man kann sich folgendermassen behelfen:
<c>
#include <avr/eeprom.h>

#ifndef EEMEM
#define EEMEM __attribute__((section (".eeprom")))
#endif
</c></ref>, das analog zu PROGMEM verwendet wird.

<c>
#include <stdint.h>
#include <avr/eeprom.h>

/* Byte */
uint8_t eeFooByte EEMEM = 123;

/* Wort */
uint16_t eeFooWord EEMEM = 12345;

/* float */
float eeFooFloat EEMEM;

/* Byte-Array */
uint8_t eeFooByteArray1[] EEMEM = { 18, 3, 70 };
uint8_t eeFooByteArray2[] EEMEM = { 30, 7, 79 };

/* 16-bit unsigned short feld */
uint16_t eeFooWordArray1[4] EEMEM;
</c>

=== Bytes lesen/schreiben ===

Die avr-libc Funktion zum Lesen eines Bytes heißt eeprom_read_byte. Parameter ist die Adresse des Bytes im EEPROM. Geschrieben wird über die Funktion eeprom_write_byte mit den Parametern Adresse und Inhalt. Anwendungsbeispiel:

<c>
#define EEPROM_DEF 0xFF

void eeprom_example (void)
{
uint8_t myByte;

// myByte lesen (Wert = 123)
myByte = eeprom_read_byte (&eeFooByte);

// der Wert 99 wird im EEPROM an die Adresse der
// Variablen eeFooByte geschrieben
myByte = 99;
eeprom_write_byte(&eeFooByte, myByte); // schreiben

myByte = eeprom_read_byte (&eeFooByteArray1[1]);
// myByte hat nun den Wert 3

// Beispiel zur "Sicherung" gegen leeres EEPROM nach "Chip Erase"
// (z. B. wenn die .eep-Datei nach Programmierung einer neuen Version
// des Programms nicht in den EEPROM uebertragen wurde und EESAVE
// deaktiviert ist (unprogrammed/1)
//
// Vorsicht: wenn EESAVE "programmed" ist, hilft diese Sicherung nicht
// weiter, da die Speicheraddressen in einem neuen/erweiterten Programm
// moeglicherweise verschoben wurden. An der Stelle &eeFooByte steht
// dann u.U. der Wert einer anderen Variable aus einer "alten" Version.

uint8_t fooByteDefault = 222;
if ((myByte = eeprom_read_byte (&eeFooByte)) == EEPROM_DEF)
{
myByte = fooByteDefault;
}
}
</c>

=== Wort lesen/schreiben ===

Schreiben und Lesen von Datenworten erfolgt analog zur Vorgehensweise bei Bytes:

<c>
// lesen
uint16_t myWord = eeprom_read_word (&eeFooWord);

// schreiben
eeprom_write_word (&eeFooWord, 2222);
</c>

=== Block lesen/schreiben ===

Lesen und Schreiben von Datenblöcken erfolgt über die Funktionen <code>eeprom_read_block()</code> bzw. <code>eeprom_write_block()</code>. Die Funktionen erwarten drei Parameter: die Adresse der Quell- bzw. Zieldaten im RAM, die EEPROM-Addresse und die Länge des Datenblocks in Bytes als <code>size_t</code>.
<c>
uint8_t myByteBuffer[3];
uint16_t myWordBuffer[4];

void eeprom_block_example (void)
{
/* Datenblock aus EEPROM lesen */

/* liest 3 Bytes ab der von eeFooByteArray1 definierten EEPROM-Adresse
in das RAM-Array myByteBuffer */
eeprom_read_block (myByteBuffer, eeFooByteArray1, 3);

/* dito mit etwas Absicherung betr. der Länge */
eeprom_read_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer));

/* und nun mit 16-Bit Array */
eeprom_read_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer));

/* Datenblock in EEPROM schreiben */
eeprom_write_block (myByteBuffer, eeFooByteArray1, sizeof(myByteBuffer));
eeprom_write_block (myWordBuffer, eeFooWordArray1, sizeof(myWordBuffer));
}
</c>

Ebenso lassen sich float-Variablen lesen und schreiben:

<c>
#include <avr/eeprom.h>

float eeFloat EEMEM = 12.34f;

float void eeprom_float_example (float value)
{
/* float in EEPROM schreiben */
eeprom_write_float (&eeFloat, value);

/* float aus EEPROM lesen */
return eeprom_read_float (&eeFloat);
}</c>

=== EEPROM-Speicherabbild in .eep-Datei ===

Mit den zum Compiler gehörenden Werkzeugen kann der aus den Variablendeklarationen abgeleitete EEPROM-Inhalt in eine Datei geschrieben werden. Die übliche Dateiendung ist .eep, Daten im Intel Hex-Format. Damit können Standardwerte für den EEPROM-Inhalt im Quellcode definiert werden.

Makefiles nach WinAVR/MFile-Vorlage enthalten bereits die notwendigen Einstellungen, siehe dazu die Erläuterungen im [[AVR-GCC-Tutorial/Exkurs Makefiles|Exkurs Makefiles]].

Der Inhalt der eep-Datei muss ebenfalls zum Mikrocontroller übertragen werden, wenn die Initialisierungswerte aus der Deklaration vom Programm erwartet werden. Ansonsten enthält der EEPROM-Speicher nach der Übertragung des Programmers mittels ISP abhängig von der Einstellung der EESAVE-Fuse<ref>vgl. Datenblatt Abschnitt Fuse Bits</ref> nicht die korrekten Werte:
; EESAVE = 0 (programmed): Die Daten im EEPROM bleiben erhalten. Werden sie nicht neu geschrieben, so enthält das EEPROM evtl. Daten, die nicht mehr zum Programm passen.
; EESAVE = 1 (unprogrammed): Beim Programmieren werden die Daten im EEPROM gelöscht, also auf 0xff gesetzt.

Als Sicherung kann man im Programm nochmals die Standardwerte vorhalten, beim Lesen auf 0xFF prüfen und gegebenenfalls einen Standardwert nutzen.

=== Direkter Zugriff auf EEPROM-Adressen ===

Will man direkt auf bestimmte EEPROM Adressen zugreifen, dann sind folgende Funktionen hilfreich, um sich die Typecasts zu ersparen:

<c>
#include <avr/eeprom.h>

// Byte aus dem EEPROM lesen
uint8_t EEPReadByte(uint16_t addr)
{
return eeprom_read_byte((uint8_t *)addr);
}

// Byte in das EEPROM schreiben
void EEPWriteByte(uint16_t addr, uint8_t val)
{
eeprom_write_byte((uint8_t *)addr, val);
}
</c>

oder als Makro:

<c>
#define EEPReadByte(addr) eeprom_read_byte((uint8_t *)addr)
#define EEPWriteByte(addr, val) eeprom_write_byte((uint8_t *)addr, val)
</c>

Verwendung:

<c>
EEPWriteByte(0x20, 128); // Byte an die Adresse 0x20 schreiben
...
Val=EEPReadByte(0x20); // EEPROM-Wert von Adresse 0x20 lesen
</c>

=== Bekannte Probleme bei den EEPROM-Funktionen ===

Vorsicht: Bei alten Versionen der avr-libc wurden nicht alle AVR Controller unterstützt. Z.B. bei der avr-libc Version 1.2.3 insbesondere bei AVRs "der neuen Generation" (ATmega48/88/168/169) funktionieren die Funktionen nicht korrekt (Ursache: unterschiedliche Speicheradressen der EEPROM-Register). In neueren Versionen (z. B. avr-libc 1.4.3 aus WinAVR 20050125) wurde die Zahl der unterstüzten Controller deutlich erweitert und eine Methode zur leichten Anpassung an zukünftige Controller eingeführt.

In jedem Datenblatt zu AVR-Controllern mit EEPROM sind kurze Beispielecodes für den Schreib- und Lesezugriff enthalten. Will oder kann man nicht auf die neue Version aktualisieren, kann der dort gezeigte Code auch mit dem avr-gcc (ohne avr-libc/eeprom.h) genutzt werden ("copy/paste", gegebenfalls Schutz vor Unterbrechnung/Interrupt ergänzen ''uint8_t sreg; sreg=SREG; cli(); [EEPROM-Code] ; SREG=sreg; return;'', siehe Abschnitt Interrupts). Im Zweifel hilft ein Blick in den vom Compiler erzeugten Assembler-Code (lst/lss-Dateien).

* siehe auch: [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt Modules/EEPROM handling

=== EEPROM Register ===
Um das EEPROM anzusteuern, sind drei Register von Bedeutung:
;EEAR: Hier werden die Adressen eingetragen zum Schreiben oder Lesen. Dieses Register unterteilt sich nochmal in EEARH und EEARL, da in einem 8-Bit-Register keine 512 Adressen adressiert werden können.
;EEDR: Hier werden die Daten eingetragen, die geschrieben werden sollen, bzw. es enthält die gelesenen Daten.
;EECR: Ist das Kontrollregister für das EEPROM

Das EECR steuert den Zugriff auf das EEPROM und ist wie folgt aufgebaut:

:{| class="wikitable" style="text-align:center"
|+ '''Aufbau des EECR-Registers'''
|-
!Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| - || - || - ||- || EERIE || EEMWE || EEWE || EERE
|-
! Read/Write
| R || R || R || R || R/W || R/W || R/W || R/W
|-
!Init Value
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''Bedeutung der Bits'''

;Bit 4-7: nicht belegt

;Bit 3 (EERIE): ''EEPROM Ready Interrupt Enable'': Wenn das Bit gesetzt ist und globale Interrupts erlaubt sind in Register SREG (Bit 7), wird ein Interrupt ausgelöst nach Beendigung des Schreibzyklus (EEPROM Ready Interrupt). Ist einer der beiden Bits 0, wird kein Interrupt ausgelöst.

;Bit 2 EEMWE): ''EEPROM Master Write Enable'': Dieses Bit bestimmt, dass, wenn EEWE = 1 gesetzt wird (innerhalb von 4 Taktzyklen), das EEPROM beschrieben wird mit den Daten in EEDR bei Adresse EEAR. Wenn EEMWE = 0 ist und EEWE = 1 gesetzt wird, hat das keine Auswirkungen. Der Schreibvorgang wird dann nicht ausgelöst. Nach 4 Taktzyklen wird das Bit EEMWE automatisch wieder auf 0 gesetzt. Dieses Bit löst den Schreibvorgang nicht aus, es dient sozusagen als Sicherungsbit für EEWE.

;Bit 1 (EEWE): ''EEPROM Write Enable'': Dieses Bit löst den Schreibvorgang aus, wenn es auf 1 gesetzt wird, sofern vorher EEMWE gesetzt wurde und seitdem nicht mehr als 4 Taktzyklen vergangen sind. Wenn der Schreibvorgang abgeschlossen ist, wird dieses Bit automatisch wieder auf 0 gesetzt und, sofern EERIE gesetzt ist, ein Interrupt ausgelöst. Ein Schreibvorgang sieht typischerweise wie folgt aus:
:# EEPROM-Bereitschaft abwarten (EEWE=0)
:# Adresse übergeben an EEAR
:# Daten übergeben an EEDR
:# Schreibvorgang auslösen in EECR mit Bit EEMWE=1 und EEWE=1
:# (Optional) Warten, bis Schreibvorgang abgeschlossen ist

;Bit 0 EERE: ''EEPROM Read Enable'': Wird dieses Bit auf 1 gesetzt wird das EEPROM an der Adresse in EEAR ausgelesen und die Daten in EEDR gespeichert. Das EEPROM kann nicht ausgelesen werden, wenn bereits eine Schreiboperation gestartet wurde. Es ist daher zu empfehlen, die Bereitschaft vorher zu prüfen. Das EEPROM ist lesebereit, wenn das Bit EEWE=0 ist. Ist der Lesevorgang abgeschlossen, wird das Bit wieder auf 0 gesetzt, und das EEPROM ist für neue Lese- und Schreibbefehle wieder bereit. Ein typischer Lesevorgang kann wie folgt aufgebaut sein:
:# Bereitschaft zum Lesen prüfen (EEWE=0)
:# Adresse übergeben an EEAR
:# Lesezyklus auslösen mit EERE = 1
:# Warten, bis Lesevorgang abgeschlossen EERE = 0
:# Daten abholen aus EEDR

= Die Nutzung von sprintf und printf =

Um komfortabel, d.h. formatiert, Ausgaben auf ein Display oder die serielle Schnittstelle zu tätigen, bieten sich '''sprintf''' oder '''printf''' an. Alle *printf-Varianten sind jedoch ziemlich speicherintensiv und der Einsatz in einem Mikrocontroller mit knappem Speicher muss sorgsam abgewogen werden.

Bei '''sprintf''' wird die Ausgabe zunächst in einem Puffer vorbereitet und anschließend mit einfachen Funktionen zeichenweise ausgegeben. Es liegt in der Verantwortung des Programmierers, genügend Platz im Puffer für die erwarteten Zeichen bereitzuhalten.

<c>
#include <stdio.h>
#include <stdint.h>

// ...
// nicht dargestellt: Implementierung von uart_puts (vgl. Abschnitt UART)
// ...

uint16_t counter;

// Ausgabe eines unsigned Integerwertes
void uart_puti( uint16_t value )
{
uint8_t puffer[20];

sprintf( puffer, "Zählerstand: %u", value );
uart_puts( puffer );
}

int main()
{
counter = 5;

uart_puti( counter );
uart_puti( 42 );
}
</c>

Eine weitere elegante Möglichkeit besteht darin, den STREAM stdout (Standardausgabe) auf eine eigene Ausgabefunktion umzuleiten. Dazu wird dem Ausgabemechanismus der C-Bibliothek eine neue Ausgabefunktion bekannt gemacht, deren Aufgabe es ist, ein einzelnes Zeichen auszugeben. Wohin die Ausgabe dann tatsächlich stattfindet, ist Sache der Ausgabefunktion. Im Beispiel unten wird auf UART ausgegeben. Alle anderen, höheren Funktionen wie z. B. '''printf''', greifen letztendlich auf diese primitive Ausgabefunktion zurück.

<c>
#include <avr/io.h>
#include <stdio.h>

void uart_init(void);

// a. Deklaration der primitiven Ausgabefunktion
int uart_putchar(char c, FILE *stream);

// b. Umleiten der Standardausgabe stdout (Teil 1)
static FILE mystdout = FDEV_SETUP_STREAM( uart_putchar, NULL, _FDEV_SETUP_WRITE );

// c. Definition der Ausgabefunktion
int uart_putchar( char c, FILE *stream )
{
if( c == '\n' )
uart_putchar( '\r', stream );

loop_until_bit_is_set( UCSRA, UDRE );
UDR = c;
return 0;
}

void uart_init(void)
{
/* hier µC spezifischen Code zur Initialisierung */
/* des UART einfügen... s.o. im AVR-GCC-Tutorial */

// Beispiel:
//
// myAVR Board 1.5 mit externem Quarz Q1 3,6864 MHz
// 9600 Baud 8N1

#ifndef F_CPU
#define F_CPU 3686400
#endif
#define UART_BAUD_RATE 9600

// Hilfsmakro zur UBRR-Berechnung ("Formel" laut Datenblatt)
#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)

UCSRB |= (1<<TXEN) | (1<<RXEN); // UART TX und RX einschalten
UCSRC |= (1<<URSEL)|(3<<UCSZ0); // Asynchron 8N1

UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );
UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );
}

int main(void)
{
int16_t antwort = 42;
uart_init();

// b. Umleiten der Standardausgabe stdout (Teil 2)
stdout = &mystdout;

// Anwendung
printf( "Die Antwort ist %d.\n", antwort );
return 0;
}

// Quelle: avr-libc-user-manual-1.4.3.pdf, S.74
// + Ergänzungen
</c>

Sollen Fließkommazahlen ausgegeben werden, muss im Makefile eine andere (größere) Version der [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|printflib]] eingebunden werden.

= Anhang =

== Externe Referenzspannung des internen Analog-Digital-Wandlers ==

Die minimale (externe) Referenzspannung des ADC darf nicht beliebig niedrig sein, vgl. dazu das (aktuellste) Datenblatt des verwendeten Controllers. z. B. beim ATMEGA8 darf sie laut Datenblatt (S.245, Tabelle 103, Zeile "VREF") 2,0V nicht unterschreiten. HINWEIS: diese Information findet sich erst in der letzten Revision (Rev. 2486O-10/04) des Datenblatts.

Meiner  eigenen Erfahrung nach kann man aber (auf eigene Gefahr und natürlich nicht für Seriengeräte) durchaus noch ein klein wenig weiter heruntergehen, bei dem von mir unter die Lupe genommenen ATMEGA8L (also die Low-Voltage-Variante) funktioniert der ADC bei 5V Betriebsspannung mit bis zu VREF=1,15V hinunter korrekt, ab 1,1V und darunter digitalisiert er jedoch nur noch Blödsinn). Ich würde sicherheitshalber nicht unter 1,5V gehen und bei niedrigeren Betriebsspannungen mag sich die Untergrenze für VREF am Pin AREF ggf. nach oben'''(!)''' verschieben.

In der letzten Revision des Datenblatts ist außerdem korrigiert, dass ADC4 und ADC5 sehr wohl 10 Bit Genauigkeit bieten (und nicht bloß 8 Bit, wie in älteren Revisionen irrtümlich angegeben.)

= Anmerkungen =
<references/>

= TODO =
* Aktualisierung Register- und Bitbeschreibungen an aktuelle AVR
* stdio.h, malloc()
* "naked"-Funktionen
* Übersicht zu den C bzw. GCC-predefined Makros (__DATE__, __TIME__,...)
* Bootloader => erl. [[AVR Bootloader in C - eine einfache Anleitung]]
* [http://myweb.msoe.edu/~barnicks/courses/CE-2800/documents/Mixing%20C%20and%20assembly%20language%20programs.pdf Mixing C and assembly language programs] Copyright © 2007 William Barnekow (PDF).

[[Kategorie:avr-gcc Tutorial| ]]

Kategorie:AVR-Boards

2011-12-24T12:57:00Z

Mthomas: Schützte „Kategorie:AVR-Boards“: Weblink-Spam ([edit=autoconfirmed] (bis 24. März 2012, 12:57 Uhr (UTC)) [move=autoconfirmed] (bis 24. März 2012, 12:57 Uhr (UTC)))

In dieser Kategorie findest Du selbst entwickelte AVR-Entwicklungsboards und Beschreibungen zu käuflichen AVR-Entwicklungs-Kits.

Siehe dazu auch [[:Kategorie:AVR-Programmer und -Bootloader]]

[[Category:AVR]]
[[Category:Boards]]

Port-Expander PCF8574

2011-12-20T21:34:21Z

Mthomas: Änderungen von 193.36.189.20 (Diskussion) rückgängig gemacht und letzte Version von Andreas wiederhergestellt

''Autor: Alexander Starke''

=Einleitung=

Einen weiteren nützlichen Baustein am [[I2C]]-Bus stellen Port-Expander dar. Wer schon einmal unter "chronischem Pinmangel" in einer seiner Applikationen gelitten hat, weiss was ich meine.

Meine Wahl ist hier auf den PCF8574 gefallen, einen 8-Bit I/O Expander. Auch in diesem Abschnitt gilt analog zu den anderen über I2C-Bausteine: Falls ihr noch nie etwas mit dem I2C gemacht habt, dann lest euch bitte zuerst die entsprechende Rubrik durch. Danach wird das Verstehen wesentlich einfacher fallen.

=Funktion=

Die Funktionsweise ist schnell beschrieben: Ein seriell an den Baustein gesendeter Wert wird auf dessen Pins parallel ausgegeben. Es gibt drei Adresspins (A0:2), an welchen man die Adresse in Hardware einstellen kann (Pins jeweils auf Masse bzw. Vcc legen). Es können also maximal 2^3 = 8 Bausteine vom Typ PCF8574 und maximal 2^3 = 8 Bausteine vom Typ PCF8574A direkt am Bus betrieben werden. Will man mehr ICs anschliessen ist ein I2C-Multiplexer notwendig (z. B. PCA9544A).

http://www.mikrocontroller.net/mc-project/Pages/Projekte/ICs/Port%20Expander/expander-pins.gif

An den Pins P0:7 kann ein 8 Bit Wert ausgegeben bzw. eingelesen werden. SDA und SCL dienen der Kommunikation über den I²C-Bus. /INT dient dazu, eingehende Daten an den Pins des Bausteins zu signalisieren. Man kann diesen Pin direkt an einen der Pins (externe Interrupts: INT0, INT1) des Mikrocontrollers legen. Da der Expander mit einem Open-Drain Ausgang daher kommt, muss ein Pull-Up gegen Betriebsspannung geschaltet werden. So kann der PCF8574 dem Mikrocontroller ohne den Umweg über den I2C übermitteln, dass sich die Eingangssignale geändert haben. Man kann ihn natürlich auch einfach offen lassen. Die Pins P0:7 können bis zu 25mA aufnehmen, aber nur gegen GND! Denn es handelt sich um [[Ausgangsstufen Logik-ICs|Open Collektor Ausgänge]]. Ausgeben können die IOs nur ca. 100µA über den interen Pull-Up Widerstand (welcher genaugenommen eine [[Konstantstromquelle]] ist). Kurzzeitig kann dieser Pull-Up 1mA liefern, wenn ein Ausgang von LOW auf HIGH schaltet, das verkürzt die Umschaltzeit wesentlich. Der gesamt aufgenommene Strom sollte 200mA nicht überschreiten.

=I²C Kommunikation=

Gestartet wird die Kommunikation durch das Senden der Start-Bedingung gefolgt vom Adressbyte.

Das Adressbyte für den PCF8574:

{| border="1"
! Bit 7 || Bit 6 || Bit 5 || Bit 4 || Bit 3 || Bit 2 || Bit 1 || Bit 0 || Hexadezimal
|-
| align="center" | 0
| align="center" | 1
| align="center" | 0
| align="center" | 0
| align="center" | A2
| align="center" | A1
| align="center" | A0
| align="center" | R/W
|| 0x40 + A[2:0]*2 + R/W
|}

Das Adressbyte für den PCF8574'''A''':

{| border="1"
! Bit 7 || Bit 6 || Bit 5 || Bit 4 || Bit 3 || Bit 2 || Bit 1 || Bit 0 || Hexadezimal
|-
| align="center" | 0
| align="center" | 1
| align="center" | 1
| align="center" | 1
| align="center" | A2
| align="center" | A1
| align="center" | A0
| align="center" | R/W
|| 0x70 + A[2:0]*2 + R/W
|}
Der Adresse (4Bit für die eindeutige Kennung + 3 frei wählbare Bits) folgt das obligatorische R/W-Bit, welches festlegt, ob ein Lese- oder Schreibzugriff ausgeführt werden soll (R/W=0 Schreiben, R/W=1 Lesen).

Wurde ein ACK empfangen, d.h. hat sich ein Slave angesprochen gefühlt, so kann man nun ein Datenbyte senden (R/W=0) oder den Status der Eingänge einlesen (R/W=1), also ein Datenbyte empfangen. Wurde ein Byte gesendet, so bestätigt der Baustein dieses mit ACK. Der Anwender kann nun festlegen, ob er das nächste Byte senden möchte oder ein STOP senden. Wurde ein Byte gelesen, so hat der Master dieses per ACK zu bestätigen, so er denn gleich das nächste empfangen möchte. Ansonsten kann hier das ACK entfallen und ein STOP gesendet werden.

Stellt sich nur noch die Frage: Wie regelt man nun, ob ein Pin als Ein- oder Ausgang arbeiten soll? Soviel gleich vorweg: So etwas wie die Datenrichtungsregister des [[AVR]]s gibt es hier nicht, man muss ohne sie auskommen. Den Ausgangspegel der Pins definiert man über einen Schreibzugriff. Sendet man beispielsweise nach der Adresse gefolgt vom ACK des Bausteins 0xF0, so bedeutet das, dass P0:3 nun L-Pegel haben und P4:7 H-Pegel. Will man einige IOs als Eingänge verwenden, muss man die entsprechenden Ausgänge zunächst auf H-Pegel setzen, da es sich um [[Ausgangsstufen Logik-ICs|Open Collektor Ausgänge]] handelt sind die Ausgänge somit inaktiv. Führt man nun einen Lesezugriff durch, so stehen im gelesenen Byte die Pegel der Pins.

=Anwendung=

Im nachfolgenden Bild sind verschiedene Anwendungen der IOs dargestellt.

[[Bild:PCF8574.png|640px]]

* P0..P3 - Ausgänge für LEDs: Die LEDS sind mit ihrer Anode über einen Vorwiderstand gegen VCC verdrahtet. Eine LED wird eingeschaltet, indem der jeweilige Ausgang auf LOW gesetzt wird (LOW aktive). Es ist NICHT möglich, die LEDs mit ihrer Kathode gegen GND zu verdrahten, da die Ausgänge vom Typ [[Ausgangsstufen_Logik-ICs#Open_Collector| Open Collector]] sind und nur bei LOW große Ströme schalten können.
* P4 - Ausgänge für ULN2003 & Co: Hier wird bei HIGH doch schon richtig Strom gebraucht (ca. 1mA). Das kann der IC nicht selber liefern (typisch ca. 100µA). Deshalb wird hier ein relativ niederohmiger Pull-Up Widerstand benötigt.
* P5 - Ausgänge für Logikbausteine: Nichts besonderes.
* P6 - Eingänge für Logikbausteine: Der Logikbaustein muss bei LOW bis zu 300µA Strom liefern können, da die internen Pull-Up Widerstände darauf dimensioniert sind und man sie nicht abschalten kann.
* P7 - Eingänge für Taster: Die internen Pull-up Widerstände sind hier nützlich.

=Software=

Routinen zum Ansteuern des Baustein können hier herunter geladen werden:
* [http://www.mikrocontroller.net/mc-project/Pages/Projekte/ICs/Port%20Expander/Portexpander%20Beispiel.zip Portexpander Beispiel.zip]

[[Category:Mc-project.de]]
[[Kategorie:Portexpander]]
[[Kategorie:I2C]]

Elektronikversender

2011-12-08T19:06:59Z

Mthomas: /* Elektronikladen */

== Einleitung ==

Die Vor- und Nachteile von verschiedenen Elektronik-Versand-Händlern werden relativ häufig im Forum diskutiert. Diese Diskussionen führen nicht selten zu weitestgehend gleichen Ergebnissen. In diesem Artikel sollen daher die Argumente, die für oder gegen einen bestimmten Elektronik-Versender sprechen, zusammengetragen werden. Sobald diese Liste einigermaßen vollständig ist, würde dies sicher einige Diskussions-Threads und/oder Flame-Wars überflüssig machen.

Diese Liste erhebt keinerlei Anspruch auf Vollständigkeit, d.h. wenn ihr einen Versender kennt, der hier noch nicht aufgeführt ist, dann nennt wenigstens die URL und den Namen. Den Rest können auch andere besorgen, die den Versender ebenfalls kennen!

Bitte ergänzt nur allgemeine Sachen (z. B. "liefert immer vollständig", "günstig" oder "große Auswahl"), aber nicht Sachen wie "mein ATMega 128 hatte verbogene Beine"! Bitte auch die alphabetische Sortierung beibehalten!

'''Diese Seite kann nur von angemeldeten Benutzern bearbeitet werden!'''

== Liste der Versender ==

=== Amidon ===
Homepage: http://www.amidon.de

* Sehr großes Sortiment, vorallem für seltene Bauteile, z. B. Dioden

=== AATiS ===
Homepage: http://www.aatis.de

* Arbeitskreis Amateurfunk und Technik in der Schule e.V.
* Bausätze speziell auch für Elektronik-Anfänger, Schüler
* Literatur, Seminare für Lehrer

=== Actron ===
Homepage: http://www.actron.de

* '''kein''' Online-Shop!
* alphanumerische LCDs und Graphikdisplays in großer Auswahl, auch mit Touchscreens
* für gewerbliche Kunden: etwas verhandeln schadet nie
* bei kleinen Stückzahlen nicht ganz billig
* liefern sehr schnell und stets zuverlässig

=== Adapterprofi ===
Homepage: http://www.adapterprofi.de

* Bauteile, Gehäuse, Netzteile
* Viele unterschiedliche HF-Adapter

=== AK Modul Bus Computer GmbH ===
Homepage: http://www.ak-modul-bus.com/stat/produkte.html

* Interfaces, Messmodule, Funktionsmodelle, Experimentiersysteme
* Entwicklungssysteme, Baugruppen, Elektor, Zubehör, Bauelemente
* Software, Lernpakete, Bücher, Sonderposten

=== Allpax ===
Homepage: http://www.allpax.de

* Liefert auch an Privathaushalte
* Keine Elektronik an sich, aber ggf. nützliches Zubehör: Größeres, übersichtliches Sortiment an ESD-Beuteln und -Folien, offen und mit Zippverschluss, Pink Poly und Metallisiert (High Shield). Preislich über Farnell, dafür findet man sofort, was man sucht...
* außerdem Ultraschallreiniger, Waagen und Folienschweißgeräte, sowie viel Fachfremdes
* Versandkosten: 8,33€ nach Deutschland, diverse EU-Länder 17,85€, Schweiz 34,51€; Versandkostenfrei in D ab 178,50€
* Gewährt scheinbar auch Privatkunden die Zahlung per Rechnung; bei Bankeinzug 2% Rabatt, bei Vorkasse und Abholung 3%

=== AME-Engineering ===
Homepage: http://www.ame-engineering.de

* Hochfrequenz-Spezialitäten, Amateurfunk

=== Andy's Funkladen ===
Homepage: http://www.andyfunk.de

* Alles für Amateur- und CB-Funk
* Bauteile und Gehäuse

=== Atlantis Shop 24 ===
Homepage: http://www.atlantis-shop24.de

* Elektronik nur ein kleiner Teil des Angebotes. Ansonsten eher Drogerie bzw. Haushaltsbedarf

=== Atzert-Elektronik Versand ===
Homepage: http://www.atzert-elektronik.de

Früher ''EFB-Electronic Versand'', davor ''MEGAKICK Electronic Stores''.

* Mindestens schon der dritte Name und die dritte Webseite für den Endkunden-Versand von [[Elektronikversender#ETT|ETT]]. ETT liefert sonst nur an gewerbliche Kunden.
* Ladengeschäfte in Bielefeld, Braunschweig, Bremen, Hamburg und Berlin.
* Die Preise schwanken im Vergleich zu anderen Anbietern, welche ebenfalls ETT-importierte Produkte führen, mal nach oben, mal nach unten.

=== Bassenberg Elektronik ===
Homepage: http://www.bassenberg.de

* Ladengeschäfte in Braunschweig und Neumünster
* Beschafft auch nicht mehr gelistete und abgekündigte Bauteile
* Liefert auch an Privat

=== Batronix ===
Homepage: http://www.batronix.com
* Grosses Sortiment an Geräten
* Bausätze für Microcontroller-Applikationen
* Liefert auch an Privat

=== BAZ Spezialantennen ===
Homepage: http://www.spezialantennen.de

* Antennen für Amateurfunk, ISM, WLAN usw.

=== Bfi-Optilas ===
Homepage: http://www.bfioptilas.de

* Kein Onlineshop
* spezialisierter Distributor für Hochfrequenzhalbleiter und Optik

=== BG-Electronics.de ===
Homepage: http://www.bg-electronics.de

* Online Shop für aktive und passive elektronische Bauelememte
* günstige Preise
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, CarHiFi und TV-Bereich

=== B & M electronics ===
Homepage: http://www.bmelectronics.de

* Bauteile, Platinen und Baugruppen für Amateurfunk

=== Box73 ===
Homepage: http://www.box73.de

Onlineshop des Funkamateur.

* Bauteile, Bausätze, Literatur aus dem Amateurfunkbereich
* Preise sind O.K.
* Bestellungen werden nur Di und Do bearbeitet
* Ab 50 EUR bei Bankeinzug portofrei.

=== Bürklin OHG ===
Homepage: http://www.buerklin.com

* große Auswahl, hohe Verfügbarkeit
* sehr schneller Versand
* Ladengeschäft in München
* <s>nur an gewerbliche Abnehmer (lt. AGB), private Abnehmer können dennoch im Ladengeschäft einkaufen Angeblich versendet Bürklin seit November 2010 auch an Privatpersonen. Allerdings verlangt Bürklin weiterhin in Adressformularen die Eingabe eines Firmennamens Geben Sie einen Wert in das Feld "Firma" ein. Daher ist diese Information eher mit Vorsicht zu genießen.</s> Mittlerweile muss man auch keinen Firmennamen mehr eingeben. Die AGB wurde ebenfalls angepasst.
* 35 EUR Mindestbestellwert, darunter 7 EUR Bearbeitungskosten (incl. MWSt)

=== CBsoft, s.r.o. (ltd.) ===
*Homepage: http://www.jjtubes.eu/
* Firma in der Slowakei
* Verkauft Röhren der Firma JJ
* englischsprachig
* Zahlungsmöglichkeiten in € mit Paypal und Kreditkarte

=== chiptrade.com ===
Homepage: http://www.chiptrade.com
* kein Onlineshop!
* Produkte von: Trinamic Motion Control, Datasphere/BlueSerial, connectBlue, Tectus RFID, Korenix, CentiPad, eye2m und Televideo

=== ConeleK Electronic ===
Homepage: http://www.conelek.com

* Sehr kleines Bauteileangebot (Röhren, Röhrensockel)
* Elektronik-Laborbedarf, insbesondere Nachfüllpackungen mit Steckbrett-Drahtbrücken
* Werkzeug für Elektronik
* Stromversorgungen
* Versand an Privat
* Versandkosten bis 25kg, Vorkasse 5,90€ (Stand 04/2008)

=== Conrad ===
Homepage: http://www.conrad.de und http://www.business.conrad.de

* großes Angebot (für Bauteile den "Business"-Katalog beachten, der Hauptkatalog ist dahingehend etwas "dünn") (Anm.: Bauteile, die nur im Business-Katalog aufgeführt sind, sind in Ladengeschäften nur über Sonderbestellung zu bekommen, d.h. dort in aller Regel nicht vorrätig.)
* Positiv: Wirklich jedes Bauteil kann einzeln gekauft werden und wird nicht in dämlichen Verpackungseinheiten verkauft, so wie es bei den meisten anderen Elektronik-Lieferanten der Fall ist. Dies ist vor Allem für den Prototypenbau sehr hilfreich.
* relativ teuer jedoch bis zu 10% Rabatt für Schulen (bei genügend Umsatz)
* 21 Ladengeschäfte in Deutschland, fünf in Österreich
* positiv: Bei Business-Kunden wird der Rechnungsbetrag erst nach 14 Tagen abgebucht.
* haben einen (teuren) 24 Std. Lieferservice für Notfälle - Conrad garantiert aber nicht 100%ig für die Einhaltung der 24 Stunden. Bei Nichteinhaltung gibt es kein Geld zurück.
* Verfügbarkeit in Filialen kann Online überprüft werden.
* Verfügbarkeit in Filialen kann über zentale Rufnummer erfragt werden. Abholung bestellter Ware in Filialen möglich, aber trotzdem gleiche Versandkosten.


=== csd-electronics ===
Homepage: [http://www.csd-electronics.de csd-electronics.de]

* ATMEL, ICs, Passive und Mechanische Bauteile, Platinen- und Lötzubehör, u.a.
* günstig
* Mengenrabatte für fast jedes Produkt
* Versand innerhalb Deutschlands pauschal 3,59€ (ab 100 EUR versandkostenfrei)
* Versand EU-weit ab 6,95 EUR
* kein Mindestbestellwert
* schnelle Lieferung, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage beschafft werden.
* Zahlung bei Vorkasse(2% Skonto), Bankabbuchung, Kreditkarte, PayPal
* Ist man bereits Kunde, kann man "auf Rechnung" (Zahlung innerhalb von 21 Tagen) bestellen.
* haben ein Forum, in dem man sich zu Sammelbestellungen organisieren kann und auch allgemeine Fragen stellen kann -zur Zeit (05/2008) offline-

=== dad24 ===
Homepage, Shop: http://dad24.eu
E-Bay Shop: http://stores.ebay.de/Shop-dad24

* Unterschiedliche Preise in den beiden Shops
* Kleiner, nicht sonderlich schöner Onlineshop (dad24.eu)
* Kleines Angebot. Lupenleuchten, Lötstationen, Labornetzgeräte, Messgeräte, etc. aus dem unteren Preissegment
* Jede Woche eine neue "Kategorie der Woche" auf dad24.eu. Produkte aus der Kategorie werden erst im Warenkorb mit einem Rabatt angezeigt, der auch gewährt wird.

=== Darisus ===
Homepage: http://www.darisus.de

* kompetente Beratung
* liefert sehr zuverlässig, in Notfällen auch Express
* Versand innerhalb Deutschlands ab 4,50 EUR
* Hat auch eine gute Auswahl an CPLDs und einige FPGAs diverser Hersteller

=== DES - Der Elektroniker-Shop ===
Homepage: http://www.DerElektronikerShop.de

* Bauteile
* Bauteilsätze der [http://www.DieElektronikerseite.de Elektronikerseite]
* Verkauf des BasicBeetle und Zubehör von [http://www.DieProjektseite.de der Projektseite]
* Ständig wachsendes Angebot
* Auch einige SMD-Bauteile verfügbar
* Kein Mindestbestellwert
* Versandkosten ab 3,50 EUR (Österreich/Europa ab 4,00 Eur)
* Versand auch nach Österreich (Europa auf Anfrage)
* Zahlung per Vorkasse
* Lieferzeit 1-3 Tage bei Verfügbarkeit
* PrePaid-Konto möglich
* Lieferungen auch an Privat

=== Digi-Key ===
(tlw.) deutsche Homepage: http://de.digikey.com

* optisch nicht besonders ansprechende, aber durchaus sehr funktionelle Website
* beheimatet in den USA, ein Logistikbüro gibt es in den Niederlanden
* kostenloser Versand ab 65€, darunter 18€ Versandkosten
* macht merkwürdige Plausibilitäts-Checks: wenn man privat über ihrem Dollar Limit (z.B. 400 Dollar bestellt) kommt sofort die Rückfrage nach Firmenname und Firmenadresse
* Rückfragen nach dem Verwendungszweck kommen ebenfalls schon bei der Bestellung bei bestimmten Bauteilen die der Exportkontrolle unterliegen
* Versand direkt aus den USA, dafür sehr flott mit UPS Express (in rund zwei bis drei Tagen da)
* riesiges Angebot, gewissermaßen ein Distributor der auch Kleinmengen an Privatpersonen liefert, entscheidend ist, dass der Hersteller des Produkts geführt wird
* kein anderer Anbieter, bietet so viele verschiedene passive Bauteile in kleinen Stückzahlen, z. B. SMD Widerstände in Bauform 01005 bis 2512 meist in verschiedenen Toleranzklassen und von verschiedenen Herstellern
* alle Bauteile mit Herstellerangabe, Digikey kauft ausschließlich direkt vom Hersteller
* Preise sind auf der deutschen Website in Euro inklusive etwaigem Zoll angegeben, allerdings ohne Mehrwertsteuer, die korrekt abgerechnet wird (d.h. man zahlt bei Versand nach Österreich 20% Mwst., nach Deutschland m.W.n. 19%)
* Meistens deutlich teurer als Reichelt, doch häufig die beste Anlaufstelle für Privatkunden wenn es um Spezialbauteile geht, und der Hersteller sich im Programm von Digikey befindet

* Zu beachten ist auch noch folgendes, um unliebsame zusatzkosten zu vermeiden: http://www.mikrocontroller.net/topic/90943#new. ''Anmerkung dazu: Digikey hat wohl zum 1.4.2011 den Versand umgestellt und importiert nun selbst. Zusatzkosten durch Verzollung sollten dann nicht mehr anfallen.''

=== Display Electronics ===

Homepage: http://www.distel.co.uk

* In England
* Webseite = Augenkrebs
* Online-Shop versteckt hinter dem Search-Button auf der Homepage
* Restposten aller Art
* Mindestbestellwert 10 GBP

=== eHaJo ===
Homepage: http://www.eHaJo.de

* Bausätze
* Lötübungen
* AVR-ISP-Stick

=== Eisch-Kafka-Electronic ===
Homepage: http://www.eisch-electronic.de

* Hochfrequenz Bausätze und Bauteile für Amateurfunk

=== EleConT ===
Homepage: http://www.elecont.de/shop/

* Carrierboards für gebräuchliche AVR

=== Electropuces ===
Homepage: http://perso.wanadoo.fr/electropuces/

* Gebrauchte Messgeräte aus Nantes, Frankreich (teilweise engl. Menü)

=== Electronic Search ===

Homepage: http://www.electronic-search.de

* Keine Mindestbestellmenge
* Verkauf auch an Privat/Bastler
* Fast alle Preise im Online-Shop nur "auf Anfrage", und nicht im Shop angegeben.

=== electronicpool Rheinstetten ===
Homepage: http://www.electronicpool.de

* abgekündigte oder schwer beschaffbare elektronische Bauteile

=== Elektronikladen ===
Homepage: http://www.elektronikladen.de

* Spezialist für Mikrokontroller
* Entwicklungssysteme, keine Einzelbauteile
* entsprechende Literatur und Software
* "Kein Verkauf an Endverbraucher i.S.d. §13 BGB"

=== Elektronik-Kompendium ===
Homepage: http://www.elektronik-kompendium.de

* Bausätze diverser Schaltungen (mit Anleitung und Funktionsbeschreibung)
* erspart lästiges Suchen in anderen Shops
* kurze Lieferzeiten
* günstiger Versand

=== Elk Tronic ===
Homepage: http://www.elk-tronic.de

* kleines Lieferprogramm Adapterplatinen (SMD -> 2,54mm-Raster) und Programmieradapter
* günstige Preise und Versandspesen

=== Ellmitron ===
Homepage: http://www.ellmitron.de/
Katalog: http://www.ellmitron.de/katalog.pdf

Lehrmittel, Kleinbausätze vor allem für Schüler, Experimentierkästen

=== Elpro Darmstadt ===
Homepage: http://www.elpro.org

* Kein Mindestbestellwert, aber hohe Versandkosten für kleine Bestellungen. Stand September 2008:
** Bis 15€: 9,95€ Versandkosten
** Von €15 bis €75: 5,95€ Versandkosten
** Von €75 bis €200: 4,49€ Versandkosten
** Ab €200: Versandkostenfrei
* Große Auswahl an Mikrocontrollern
* Sehr große Auswahl an Schaltnetzteilen von Meanwell (geschlossen, offen, auf PCB lötbar, DIN-Schiene)
* Merkwürdig zu bedienende Shopsoftware, ständig klappt was auf und zu und wird irgendwas nachgeladen. Braucht JavaScript
* Keine AGBs online. Da Preisangaben ohne MwSt. richtet sich das Angebot vermutlich nicht an Endverbraucher (werden aber beliefert)
* Bearbeitungszeit (bis Warenausgang) 2-3 Tage.
* Versand bisher mit DHL
* gute bis sehr gute Verpackung

=== Eltrix ===
Homepage: http://eltrix.de/Starteltrix.htm

* Verbrauchsmaterial, Tipps und Tricks fürs Leiterplattenherstellen und Löten

=== ELV ===
Homepage: http://www.elv.de

* nicht sehr große Auswahl an Einzelteilen
* riesiges Angebot an Zubehör für Hobbyisten
* viele z.T. pfiffige Eigenentwicklungen, Bausätze (auch zum Download auf der Website verfügbar)
* sonst Sortiment ähnlich Conrad, nicht billig
* im Allgemeinen nicht billig, merkwürdigerweise sind manche Artikel aber die günstigsten auf dem Markt
* mühsamer Onlinekatalog
* Immer mal wieder Fehllieferungen und Wartezeiten (zumindest in die Schweiz). Service erreichte in 3 Fällen nicht das inserierte Niveau.
* Versandkosten innerhalb Deutschland 4,5€, ab 150€ Bestellwert versandkostenfrei
* nicht abwählbare Versandversicherung, die 0,85% des Bestellwertes kostet



=== ETT - Electronic Toys Trading ===
Homepage: http://www.ett-online.de

* Großhandel nur für Gewerbekunden.
* Zweitshop [[Elektronikversender#Atzert-Elektronik_Versand|Atzert-Elektronik Versand]] (früher EFB-Electronic Versand, davor Megakick Electronic-Stores) für Endkunden.
* Ladengeschäft in Braunschweig für jedermann. Weitere Atzert Ladengeschäfte in Bielefeld, Bremen, Hamburg und Berlin.
* Eigentümer der Marken McCHECK®, McPower®, McVoice® und anderer, unter denen ETT importierte Messgeräte, Labornetzteile, usw. an Großkunden und Händler vertreibt. Diese sind unter oben genannten Marken dann in vielen Shops anderer Firmen für Endkunden zu finden, nicht nur bei Atzert. Preisvergleiche lohnen.

=== Ettinger GmbH ===
Homepage: http://www.ettinger.de

* Für gewerbliche Kunden
* Mechanische Komponenten (Gehäuse, Abstandshalter, Drehknöpfe, usw.)
* LEDs
* Gewöhnungsbedürftiger Online-Shop

=== EVE ===
Homepage: http://www.eve.de

* Zitat aus den AGBs:
::''"Zu Bestellungen im Rahmen des Online-Handels sind nur durch uns autorisierte, d. h. zugelassene Käufer berechtigt. Wir gewähren nach erfolgreicher Zertifizierung – ohne hierzu verpflichtet zu sein – dem jeweiligen Käufer das nicht übertragbare, nicht exklusive Recht im Rahmen des Online-Handels Bestellungen uns gegenüber “auszubringen”."''

:Dies darf man wohl getrost als Hinweis ansehen, dass Endverbraucher als Kunden nicht gewünscht sind.
* Versandhaus für elektronische Artikel in Emsdetten
* machen auch Kabelkonfektion
* Pb-freie Artikel markiert

=== Farnell ===
Homepage: http://www.farnell.de

* liefert nur an gewerbliche Abnehmer, Ausnahme sind Studenten und HTL-Schüler (Österreich, Farnell.at). Nachweis wird verlangt (Gewerbeschein oder Immatrikulation).
* Lieferungen an Privat:
:* Schweiz: Farnell Schweiz beliefert auch Privatkunden.
:* Deutschland: Über den Reseller [[#HBE_-_Heinz_B.C3.BCchner_Elektronik.2C_Messtechnik.2C_med._Elektronik_e.K.|HBE]] kann man Produkte aus dem Farnell-Sortiment zu bestellen.
:* Österreich: [[#Technik-Welt / Industrieshop.at|Technik-Welt / Industrieshop.at]]
* große Auswahl
* 12% Rabatt für Studenten und Lehreinrichtungen
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (UPS), fehlende Positionen werden relativ rasch versandkostenfrei nachgeliefert
* Versandkosten: Bestellung bis 49,99€: 7,95€; 50,- bis 149,99€: 5,95€; ab EUR 150,- versandkostenfrei
* hat nach eigenen Aussagen umfangreichstes Sortiment an RoHS-konformen Bauteilen mit Suchfunktion im WWW
* leistungsfähige parametrische Suchfunktion / teils aber völlig nutzlos, da den Artikeln massenweise Tags fehlen, weswegen die Suchergebnisse unnötig eingeschränkt werden
* Datenblätter für die meisten Bauteile online
* Internetpräsenz fällt nachts oft aus (Hinweis auf angebliche geplante Wartungsarbeiten)
* Sortierfunktion wird bei der Suche ständig zurückgesetzt, im Warenkorb ist überhaupt keine sinnvolle Sortierung möglich
* Eigenwillige Preispolitik: Einiges sehr günstig, Anderes total überteuert

=== Fibra-Brandt Zweibrücken ===
Homepage: http://www.fibra-brandt.com

* lagert tausende veraltete und schwer zu findende elektronische Bauteile
* Halbleiter, IC's, Transistoren, Spulen und Kondensatoren.
* Sonderbeschaffung von abgekündigten Halbleitern.

=== Fischer DK2FD ===
Homepage: http://www.dfe-online.de

* Baugruppen für Hochfrequenzmesstechnik und Amateurfunk

=== Funkamateur Online-Shop ===

Siehe [[Elektronikversender#Box73]]

=== Futurelec ===
Homepage: http://www.futurlec.com

* günstiger Versender aus Übersee
* viele Stamp-Boards
* LED Matrix-Module

=== Geist Electronic-Versand GmbH ===
Homepage: http://www.geist-electronic.de

* Liefern Bauteile für Elektor-Projekte
* D-78054 Villingen-Schwenningen
* Versandkosten: 5.40€

=== Giga-Tech ===
Homepage: http://www.giga-tech.de

* Spezialitäten für Hochfrequenz / Amateurfunk
* 68542 Heddesheim

=== Grummes Elektronik ===
Homepage: http://www.grummes.de

* Elektronikversender /CNC-Fräsmaschinen / Schrittmotorsteuerungen / Bauteile

=== Glyn (GLYNshop) ===
Homepage: https://www.glynshop.com/erp/welcome.do

* "B2B Shop" = nicht für Privatkunden
* Microcontroller, Evaluation Boards, TFT-Displays, LC-Displays, Memory Cards u.a.

=== Hallmanns Elektronik ===
Homepage: http://www.hallmanns.com 
Adresse: Bruno Hallmanns, Weierstraße 41, 52349 Düren

* Elektronikhändler mit Ladenlokal und Versand
* Ladentypisches Sortiment (Bauteile, Geräte, PC, Funk, Hifi...)

=== Hari Seligenstadt ===
Homepage: http://www.hari-ham.com

* Bausätze, Ringkerne, Geräte für Amateurfunk

=== HBE - Heinz Büchner Elektronik, Messtechnik, med. Elektronik e.K. ===
Homepage: http://www.hbe-shop.de/katalog/

* Bezeichnet sich als ''[[#Farnell|Farnell]] Fachhändler'', bei dem nichtgewerbliche Kunden aus dem Farnell-Sortiment bestellen können.
* Preise für Farnell-Produkte normalerweise Farnell Netto-Preis + MwSt.
* Mindestbestellwert 25,- € (netto), Mindermengenzuschlag 5,- € (Stand 06/2010)
* Versandkosten 4,75 € (netto), ab 75,- € (netto) versandkostenfrei (Stand 06/2010)

=== Heho-Elektronik ===
Homepage: http://www.heho-elektronik.de
* Halbleiter / Bauteile, Sortimente, Handy - Akkus, VELLEMAN - Bausätze
* Aktuelles Angebot, Ladegeräte / Akkuladegeräte, Blei - Akkus
* Spannungswandler, Audio / Video / USB - Kabel, Netzwerk - Kabel
* 1-2 Arbeitstage für Waren ab Lager
* Porto + Verpackung pauschal Euro 4,50
* Mindestbestellwert von € 10,00

=== Hinkel ===
Homepage: http://www.hinkel-elektronik.de

* Von der Webseite "Unser Angebot richtet sich an Schulen, Behörden, Handel, Handwerk und Industrie."
* Batterien
* Knopfzellen, spezielle KZH, die man sonst lang sucht, findet man hier
* Mindestbestellwert von 20€
* Standardversand innerhalb Deutschlands 5,80€

=== HN Electronic Components GmbH & Co. KG / Netzteilshop ===
Homepage gewerbliche Kunden: http://www.hn-electronic.de/homed/framed.html 
Homepage Endkunden: http://www.netzteilshop.com/hnshop.html

* Netzteile aller Art
* Lieferung an Endkunden nur per UPS Nachnahme.
* Mindestbestellmenge für Endkunden 25 €

=== HW-Electronics ===
Homepage: http://www.hw-electronics.de 
Homepage EU: http://hw-electronics.eu/

* Tauch- und Sprühätzanlagen
* Entwicklungsgeräte
* Belichtungsgeräte, Materialsätze zum Selbstbau von Belichtungsgeräten

=== ID-Elektronik ===
Homepage: http://www.id-elektronik.de

* Amateurfunk-Baugruppen

=== IT-WNS ===
Homepage: http://www.it-wns.de

* "Bauteile, Platinen, Bausätze" insbesondere mit ATMEGA und ENC28J60
* Bausätze zu Projekten aus dem Forum, z. B. USBprog, ChipBasic, Mikro-Webserver, Transistortester u.v.a.m.
* Atmega32/644 Experimentiersystem als Bausatz mit vielen Zusatzmodul-Bausätzen
* SD-Slots, RFID, Bluetooth-Module, AVR Mikrocontroller uvam.
* Bauelemente, die nicht im Shop angeboten werden, können auf Anfrage (Kontaktformular) beschafft werden
* günstige Preise und Versandkosten ab 1,90EUR, kein Mindestbestellwert
* schneller Versand, sofern die Artikel auf Lager sind, versandkostenfreie Nachlieferung

=== Kabelscheune ===
Homepage: http://www.kabelscheune.de

* "Direktversand von Elektromaterial und Multimediaprodukten"

=== Kelemen ===
Homepage: http://www.kelemenantennen.de/Kelemen-Shop/

* Messgeräte, Antennen und Zubehör für den Amateurfunk

=== Kessler ===
Homepage: http://www.kessler-elektronik.de

* im Preis-Leistungsverhältnis mit Reichelt zu vergleichen (sprich: günstig)
* Sortiment kleiner als Reichelt und mit gewissen Abweichungen (z. B. andere FPGA und RAMs)
* oft lange Lieferzeiten
* Versandkosten innerhalb Deutschlands 4,95€ bei Bankeinzug und 6,90€ bei Nachnahme plus Nachnahmegebühren
* Der Download-Katalog ist von 2002! Online aktueller

=== Klein-Electronic ===
Homepage: http://www.klein-electronic.de

* Baugruppen zur Video- und 2,4GHz-Sendetechnik

=== Konni-Antennen ===
Homepage: http://www.konni-antennen.de

* Antennen für TV, Amateurfunk
* Zubehör, Einzelteile

=== Köditz Nachrichtentechnik ===
Homepage: http://www.koeditz-nachrichtentechnik.de

* Baugruppen und Bauteile für Amateurfunk und TV-Satellitenempfang

=== Kuhne DB6NT ===
Homepage: http://www.kuhne-electronic.de

* Baugruppen und Bausätze für Mikrowellenamateure

=== LEDSEE Electronics ===
Homepage: http://www.ledsee.com

* LEDs, LCDs, diverses
* Lieferung direkt aus China, daher sehr günstig und lange Lieferzeiten

=== LED Microtechnics LTD ===
Homepage: http://www.ledmeile.de

* "LED Shop und Lampentechnik"

=== LED-Tech LED-Shop ===
Homepage: http://www.led-tech.de

* viele verschiedene LEDs zu sehr guten (meist den günstigsten) Preisen
* vor allem auf High-Power-LEDs spezialisiert
* viele verschiedene Treiber für High-Power-LEDs
* kostenloser Versand
* haben ein eigenes, sehr umfangreiches Forum

=== Lieske Elektronik ===
Homepage: http://www.lieske-elektronik.de

* liefert nur an Geschäftskunden

=== LUMITRONIX LEDs-Shop ===
Homepage: http://www.leds.de

* alles rund um LEDs (auch Zubehör und Lektüre)
* neben Standard-LEDs auch SMD- und SuperFlux-LEDs

=== Marsch Elektronik, M. Schlimper ===
Homepage: http://www.marsch-elektronik.de

* Online Shop für aktive und passive Bauelemente
* Versandkosten ab Euro 1,60
* kein Mindestbestellwert
* liefert nur innerhalb Deutschlands
* nicht gelistete Artikel können angefragt werden und werden meist auch beschafft

=== Mein-Daarle ===
Homepage: http://www.mein-st-arnual.de/shop/saarbruecken/artikellisteL.html

* Teileliste eines "Händlers aus Saarbrücken" (wahrscheinl.: Frank Skowronek ESS Elektronik Service), "bis sein Onlineshop ans Netz gehen kann"
* derzeit (4/2011) kein Onlineshop, Kontakt über Formular

=== Micromaus ===
Homepage: http://www.micromaus.de

* Sensoren
* Mikrokontroller
* kein Mindestbestellwert

=== Microcontroller-Starterkits ===
Homepage: http://www.microcontroller-starterkits.de

* Bauteile: CAN, Ethernet, Mikrokontroller AVR und ARM, Linearregler 1,8V 3,3V 5V in SOT223
* Leerplatinen, Bausätze
* günstig
* Abholung in Hattingen möglich
* Versandkosten innerhalb Deutschlands ab 2,50€
* keine Kreditkartenzahlung möglich

=== Mikrocontroller.net ===
Homepage: http://shop.mikrocontroller.net

* Starterkits, Development Boards und Zubehör für AVR, AVR32, ARM und MSP430

=== Mira Nürnberg ===
Homepage: http://www.mira-electronic.de

* SMD-Bauteile, SMD-Sortimentboxen
* Verkauf und Preisangaben nur für Gewerbetreibende

=== Karl Müller EME Messtechnik ===
Homepage: http://www.eme-hf-technik.de

* Hochfrequenz-Messtechnik, HF-Komponenten

=== Mouser ===
Homepage: http://de.mouser.com

* Liefert an Privat
* Zügige Lieferung mit FedEx aus den USA
* Keine Halbleiter von Linear, National und Analog

=== MS-Elektronik ===
Homepage: http://www.ms-elektronik.info

* Liefert an Privat
* Zügige Lieferung
* Gute Qualität
* Viel in Richtung Audio
* Große Auswahl an Elkos -> kleine Preise
* kein allzu großes Sortiment

=== Mütron ===
Homepage: http://www.muetronshop.de

* Keine Privatkunden

=== myAVR Shop ===
Hompage http://shop.myavr.de

* Kleine Auswahl, aber die angebotene Ware ist sehr preiswert (meist preiswerter als bei Reichelt)
* Zügige Lieferung (1-2 Werktage)
* Diverse Zahlungsmöglichkeiten: Rechnung, Vorkasse, Lastschrift, Kreditkarte, PayPal
* Kein Mindestbestellwert
* Sehr günstige Versandkosten ab 1,95 Eur
* Mengenrabatt ab 10 gleichen Artikeln

=== Neuhold-Elektronik ===
Homepage: http://www.neuhold-elektronik.at 
Shop: http://www.neuhold-elektronik.at/catshop/default.php?language=de

* preiswerte Schnäppchen
* regelmäßig aktualisierte Angebotsliste herunterladbar
* Ab 60,- EUR versandkostenfrei in Österreich

=== Octamex ===
Homepage: http://www.octamex.de

* preiswerte Leiterplattenchemie
* Chemisch Zinn
* Ätzmittel Natriumpersulfat, Eisen-III-Chlorid
* Entwickler positiv und negativ
* Lötstopp-Laminat, Tentingresist, Bestückungsdruck
* Bungard Basismaterial in 0,5mm 1,0mm 1,5mm Dicke und 18µm, 35µm, 70µm Kupfer
* Bungard Alucorex für 19" Frontplatten
* Gehäuse aller Art
* Quarze in Industriequalität
* aktive und passive Halbleiter (Widerstände, Kondensatoren, Transistoren, Logik-ICs etc.)
* kein Mindestbestellwert
* Lieferung auch ins Ausland
* Versandkosten ab 2,55EUR
* Liefert nur gegen Vorkasse, ausser für Bestandskunden, die schon häufig bestellt haben
* Zahlung mit EC-Pay oder Kreditkarte nur gegen erheblichen Aufschlag (bis zu 5%)

=== Online Batterien ===
Homepage: http://www.online-batterien.de

* Allerlei günstige Batterien & Akkus vieler Marken
* z. B. '''40 Stk.''' DURACELL PLUS LR6 AA 11,59€ (Jan 2010)
* Beleuchtungsartikel
* USV
* Versand ab 3,90€

=== Oppermann ===
Homepage: http://www.oppermann-electronic.de

* Restposten, auch HF Bauteile
* auch Privatkunden
* Lieferung nach üblicher Zeit

=== PCB-Soldering ===

Homepage, Online-Shop: http://www.pcb-soldering.co.uk
eBay: http://www.allendale-stores.co.uk
Firmen-Homepage: http://www.allendale-elec.co.uk

* [http://www.aoyue.com/en/products.asp Aoyue] Lötstationen und preiswertes Zubehör (Lötspitzen) für diese. Bei Aoyue-Zubehör bessere Preise (Stand 10/2008) als [[#WilTec_Wildanger_Technik_GmbH|WilTec]]
* Schnelle Lieferung
* Dank [http://www.zoll.de/b0_zoll_und_steuern/a0_zoelle/a1_grundlage_zollrecht/b0_zollgebiet/index.html EU Binnenmarkt] nur britische Mehrwertsteuer (VAT), kein Zoll, keine [http://www.zoll.de/b0_zoll_und_steuern/a3_einfuhrumsatzsteuer/index.html Einfuhrumsatzsteuer] fällig.
* Zwei von drei E-Mails wurden nicht beantwortet
* Versandart wurde eigenmächtig von "Standard" auf teureres "Signed for" (Einschreiben) geändert

=== Pollin Electronic ===
Homepage: http://www.pollin.de

* Günstige Restposten aller Art (z. B. "250 g verschiedene ICs" u.dgl.)
* Produktkategorien:
** Computer und Zubehör
** Telefone und Zubehör
** Antennentechnik
** HiFi/Car-HiFi/Video/TV
** Stromversorgung
** Lichttechnik
** Messtechnik / Uhren
** Haustechnik
** Werkstatt
** Bauelemente
** KFZ- und Zweirad
** Motoren
** Bausätze
** Fundgrube
* Produkte teils schnell ausverkauft
* Qualität schwankend. Man kann gute Schnäppchen machen aber auch reinfallen. Umtausch ist dann aber problemlos.
* Es wird öfters von sorgloser Verpackung berichtet, trotz Verpackungspauschale von 0,85 % des Warenwerts (empfindliche und schwere Produkte besser nicht zusammen bestellen). Reklamationen bei Beschädigungen werden freundlich behandelt.
* Lieferzeit i.d.r. 2-3 Werktage / knappe Woche bei neuer Sonderliste
* Ladengeschäft in 85104 Pförring
* Versandkosten innerhalb Deutschlands 4,50 € (ab 150€ versandkostenfrei); dazu 0,85 % Verpackungspauschale
* Zahlung per Nachnahme (+2,50 €) oder Bankeinzug (keine Kreditkarte, keine Überweisung)

=== proma / Isel ===
Homepage: http://www.proma-technologie.com/deutsch/rundum_l/proma_fs_1.html

* fotobeschichtete Leiterplatten Platinenfrästechnik
* Chemikalien für die Platinenherstellung: Ätzmittel, Flussmittel für Lötanlagen, etc.
* Profilgehäuse, u.a. von Conrad und Reichelt vertrieben

=== QRP-project ===
Homepage: http://www.qrpshop.de/sitemap.htm
* Bausätze vor allem einfache Kurzwellen-Funkgeräte

=== Reichelt ===
Homepage: http://www.reichelt.de

* relativ große Auswahl, aber nicht viele "brandaktuelle" Bauteile
* wenn man höflich fragt, liefern sie ganz selten auch Bauteile, die nicht im Katalog stehen zu "normalen" Preisen (vorausgesetzt der Hersteller ist im Sortiment), z. B. Xilinx XC2S50, aber meist erhält man die Antwort, dass der Artikel nicht im Sortiment ist, obwohl auf der Homepage unter Service extra ein Punkt angeführt ist: "Ich benötige einen Artikel, der nicht im Programm ist"
* reagiert aber teilweise auch auf Anregungen, neue Produkte in das Angebot aufzunehmen; siehe dazu auch den Artikel [[Reichelt-Wishlist]]
* liefert schnell und vollständig; wenn etwas ausnahmsweise nicht verfügbar ist, dann liefern sie es auf eigene Kosten nach, wenn der Artikel in absehbarer Zeit wieder vorrätig ist (selbst wenn er nur 0,20€ wert ist).
* lässt einen dennoch manchmal warten, wenn ein Artikel nicht lieferbar ist! Daher bei der Bestellung immer darauf hinweisen, dass man auch eine Teillieferung akzeptiert. (Laut Auskunft dauert das länger, besser nach der Inet-Bestellung anrufen und nicht lieferbare Teile aus der Bestellung streichen lassen)
* Lieferzeiten normalerweise 2 - 4 Arbeitstage
* niedrige Preise (aber unbedingt Qualität des Artikel checken)
* Versandkosten 5,60€ (Deutschland); 10€ Österreich; Schweiz 16€; EU 15 - 19€;
* 10€ Mindestbestellwert für alle Länder
* auch in die Schweiz sehr guter Service
* holt sich auch ohne Erlaubnis Bankauskünfte bei großen Bestellungen ein

=== RFW Elektronik ===
Homepage: http://www.rfw-elektronik.de

* HF Bauelemente

=== Ribu ===
Homepage: http://www.ribu.at

* Sehr guter Elektronikversand in Österreich mit zahlreichen Entwicklungsboards und zahlreichen Elektroniklösungen.
* Liefert sehr schnell und hat eine ausgezeichnete Beratung.
* Online-Shop ist sehr übersichtlich und einfach zu bedienen.
* Lieferstatusanzeige für alle Artikel. Bei Auslaufartikeln ist sogar die noch verfügbare Stückzahl sichbar.
* Günstige Sonderangebote
* innerhalb Österreichs 4,90€ Versandkosten, ab 80,- keine Versandkosten
* ausserhalb Österreichs 13€ Versandkosten, ab 225€ versandkostenfrei
* liefert auch an Privatkunden
* Mindestbestellwert innerhalb Österreichs 10€, ausserhalb 30€

=== Richardson Electronic ===
Homepage: http://www.rell.com/international/index.asp?ID=GE

* Hochfrequenz-Halbleiter, HF-Röhren,

=== Riedl Elektronik ===
Homepage: http://www.riedl-electronic.at

* großes Angebot v.a. ICs und Trafos
* recht günstig
* Rabatt für Schüler/Student
* Versand nach AT: 3,95€ bis 1kg, ab 100€ frei Haus
* Versand AT über 1kg sowie Ausland: Nach Aufwand (wird nicht direkt angezeigt)

=== RLX COMPONENTS s.r.o. ===
Homepage: http://www.rlx.sk

* Man spricht Deutsch
* Messgeräte, Mikrocontroller-Boards, Bauelemente

=== RM Computertechnik GmbH ===
Homepage: http://www.rm-computertechnik.de

* Kerngeschäft ist PC-Technik, aber auch großes Sortiment an Kabeln, Litzen und Steckverbindern
* handelt auch mit einigen Bauelementen, wie LED's

=== Robotikhardware===
Homepage: http://www.robotikhardware.de

* Microcontroller
* Entwicklungsboards
* Sensoren
* Robotik-Zubehör
* günstiges Angebote für Hobby-Elektroniker
* auch einzelne Platinen

=== Benno Rößle Elektronik ===
Homepage: http://www.roessle-elektronik.de

* Masten, Antennen, Befestigungsmat.,Zubehör, Geräte, Anpassteile, HF-Stecker

=== RS Components ===
Homepage: http://www.rsonline.de

* lt. AGB nur an gewerbliche Abnehmer, fragt bei Internetbestellungen aber nicht nach. Anm.: mitlerweile machen sie es doch.
* gute Auswahl insbesondere an "mechanischen Bauteilen"
* gute Verfügbarkeit
* sehr schneller Versand, Ware ist in 99% aller Fälle am nächsten Tag da (GP)
* Preise wurden angepasst, gute Preis/Leistung
* Preis im Onlineshop sind ohne MwSt angegeben
* Bei Onlinekauf ist der Versand kostenfrei, ohne Mindesbestellwert.
* Notify-Me Service für Produktabkündigung
* Auch größere Stückzahlen über Allied möglich
* Relativ große Auswahl an Sortimenten (Widerstände, Kondensatoren), Einzelteile können teilweise nachgekauft werden
* Verfügbarkeitsanzeige im Internet ist ziemlich hilfreich
* Nützliche Tipps zum Thema RoHS

=== Sander Elektronik ===
Homepage: http://www.sander-electronic.de

* beliefert auch Privatkunden, Bankeinzug möglich
* ähnlich Segor ein Berliner Versender
* Hier findet man manche [[MSP430]], die es sonst nicht in kleinen Stückzahlen gibt
* Herr Sander ist sehr kompetent und selbst Autor von Fachartikeln
* selbst abgekündigte Halbleiter können noch beschafft werden
* Bezahlung auch mit Kreditkarte möglich
* Versandkosten innerhalb Deutschlands ab 3,35€, innerhalb Europas ab 6€

=== Sasco Holz ===
Homepage: http://www.sasco.de

* Wie Spoerle eine Tochter von Arrow.
* Distributor für Analog Devices...
* Liefert wie Spoerle und Arrow in Deutschland nicht an Privatkunden.

=== Sat-Schneider ===
Homepage: http://www.sat-schneider.de
* Bauteile, Ersatzteile Online-Shop
* Baugruppen zum Empfang des Digitalen Kurzwellenrundfunks DRM

=== Otto Schubert GmbH ===
Homepage: http://www.schubert-gehaeuse.de

* Kein Online-Shop. Bestellungen nur per Telefon, Fax oder E-Mail
* Weissblechgehäuse, Gerätegehäuse, wetterfeste Gehäuse
* Drehkondensatoren
* Sonderanfertigungen

=== Schramm-Software ===
Homepage: http://www.schramm-software.de/bausatz/
* Online-Shop, bietet Elektronik-Bausätze mit Mikrocontrollern
* Bausätze als Lehrmaterial geeignet, da ausführliches Begleitheft mitgeliefert wird (Aufbauanleitung, Schaltung, Controllerprogramm, Experimente...)
* bisher nur ein relativ kleines Sortiment, soll ergänzt werden
* Versandkosten innerhalb Deutschlands 2,50 €, innerhalb der EU 3,50 €

=== Schukat elektronic ===
Homepage: http://www.schukat.de

* liefert nicht an privaten Endverbraucher
* einfache und passiver Bauteile oft nur in großen Mindeststückzahlen
* ICs teilweise recht preiswert (vor allem bei mehr als 1 Stück, z. B. auch AVR)
* LCDs sehr preiswert und auch als Einzelstücke
* aktuelle Preise und Verfügbarkeit im Internet (aber nur nach Anmeldung -jetzt nicht mehr bei kleinen Stückzahlen), ebenso Bilder von Gehäusefootprints u.dgl.
* Abholung in Monheim am Rhein nach Vereinbarung möglich
* Versandkosten innerhalb Deutschlands ab 5€ (bis 10kg!)

=== Schuricht ===
Homepage: http://www.schuricht.de

* deutscher Ableger der Distrelec- (Elektronik) und Disdata-Gruppe (Computertechnik)
* Liefert auch an Privatkunden (getrennte AGBs für gewerbliche und Privatkunden, Lieferung an Privat per Nachnahme: Versandkosten ab 6,54€ plus 4,76€ Nachnahmegebühr).
** Online-Bestellung von Privatkunde scheiterte daran, dass die Onlineshop-Bestellformulare nur für gewerbliche Kunden ausgelegt sind und der Onlineshop Bestellungen ohne Firmenangaben nicht annimmt oder gar mit einer internen Fehlermeldung quittierte.
**Online Bestellung mit "Privat" als Firmenangabe funktionierte einwandfrei.
**Telefonische Bestellung von Privat funktioniert. Nette, freundliche Behandlung am Telefon, kein Callcenter. Versprochener Rückruf erfolgte mit gewünschten Informationen. Neben Nachnahme wurde für einen relativ teuren Artikel persönliche Abholung angeboten. Angegebene Lieferfrist wurde leicht unterschritten.
* Papierkatalog über 2000 Seiten, durchgehend farbig, nur für Geschäftskunden erhältlich.
* Ziemlich teuer

=== Schuro Elektronik GmbH ===
Homepage: http://www.schuro.de

* Elektronische Bauelemente und Bauteile für den Audio- und Lautsprecherbau (Kondensatoren, Spulen u.dgl.)
* kein Mindestbestellwert
* Versandkosten innerhalb Deutschlands gewichtsabhängig ab 5,75€

=== Segor-electronics ===
Homepage: http://www.segor.de

* Spezialist für Halbleiter, die ansonsten für nicht-gewerbliche Abnehmer nur schwer erhältlich sind (Preise dahingehend "angemessen")
* auch Privatkunden gerne gesehen
* Ladengeschäft in Berlin
* kein Mindestbestellwert bei Versand innerhalb der EU

=== SE Spezial-Electronic AG ===
Homepage: http://www.spezial.de

* Distributor
* Laut AGB auch Verkauf an Privat.
* Große Verpackungseinheiten/Mindestbestellmengen pro Bauteil
* Versandkosten pauschal 9,- € (Deutschland) (Stand 08/2008)

=== Shortec Electronics ===
Homepage: http://www.shortec.com

* Unabhängiger Distributor von elektronischen und elektromechanischen Bauelementen aller Hersteller.

=== Small Control Shop ===
Homepage: http://www.small-control.de

* "Bernd Walter Computer Technology"
* kleines Lieferprogramm aber ein paar interessante Produkte

=== SMG Diffusion - F1GE ===
Homepage: http://www.smgdiffusion.com
( Seite nur französisch )

* Videotechnik,
* 1,2 GHz / 2,4GHz Module
* Gebraucht-Messgeräte HP, Tek, Philips u.a.
* GHz-Halbleiter
* Koax-Adapter
* Antennen

=== Spoerle ===
Homepage: http://www.spoerle.de

* Früher eine Tochterfirma von Arror. Mittlerweile komplett in Arrow aufgegangen, Webseite leitet auf Arrow um.
* Aus dem Webshop: "Unser Angebot richtet sich nur an Kaufleute und nicht an Verbraucher."
* Wenn es wirklich über Arrow sein muss, dann kann man es als Privatperson bei Arrow Electronics North American Components http://www.arrownac.com/ versuchen, die sich normalerweise nicht weigern ihre Produkte zu verkaufen. Allerdings muss man mit großen Mindestmengen (z. B. BC547 in Schritten von 2000 Stück) und hohen Kosten rechnen.
:Zu den Kosten gehören zum Beispiel ein mehrfacher Mindermengenzuschlag (''$10 handling charge will be added to each line item less than $30''), eine satte ''handling and energy fee of $10.22'' (mehr als 10x zu hoch wie die vergleichbare Gebühr für amerikanische Besteller), hohe Versandkosten (ab $20 nach Deutschland). Dazu kommen die üblichen Kosten für den Import aus dem Ausland (Einfuhrumsatzsteuer, Kreditkartengebühr, ...)

=== SR-Systems ===
Homepage: http://www.sr-systems.de

* Baugruppen für Digital-TV, Sende- und Empfangstechnik
* DVB-S, DVB-T

=== Strixner&Holzinger ===
Homepage: http://www.sh-halbleiter.de

* Ladengeschäft in München
* Versand
* riesiges Angebot an Halbleiter, auch schwer beschaffbare
* Online-Shop

=== TAUTEC-ELECTRONICS ===
Homepage: http://www.tautec-electronics.de

* Online Shop für aktive elektronische Bauelemente
* günstige Preise (Vorsicht, Preisangaben enthalten keine Mehrwertsteuer) aber Mindestbestellwert 100 Euro
* alle Artikel ab Lager lieferbar, daher kurze Wartezeiten
* weltweiter Versand
* zahlreiche Mengenrabatte
* viele Ersatzteile aus dem Audio-, Car-HiFi und TV-Bereich

=== TCB-Versand ===
Homepage: http://www.tcb-versand.de

* insbesondere für Modellbauer ein sehr interresantes Sortiment
* Stecker,Kabel etc. recht günstig und kleine Mengen abnehmbar
* Lieferung normal zwischen 1 und 3 Tage
* leider nur Online-Shop

=== Tec-Shop (Wolfgang Rompel Elektronik) ===
Homepage: http://www.tec-shop.de www.tec-shop.de

* Kleines, aber ausgesuchtes Sortiment
* Interessantes Angebot an Sensoren

=== Technik-Welt / Industrieshop.at ===
Homepage: http://www.industrieshop.at

* Laut Homepage richtet man sich "an den industriellen Kunden". Laut AGB sieht man das jedoch nicht so eng, Zitat:
:: ''TW schließt online Verträge nur mit Kunden ab, die natürliche oder juristischen Personen sind, die ihren Wohnsitz oder Sitz in Österreich, einem Mitgliedsstaat der Europäischen Union (EU25) oder der Schweiz haben.''
* [[#Farnell|Farnell]] Teile
* In Österreich
* Schnelle Lieferung (2 Tage)

=== TIGAL KG ===
Homepage: http://www.tigal.com

* Boards und Tools für Embedded-Elektronik
* In Österreich
* Versandkosten ab € 7,00 in Österreich, ab € 10,00 nach Deutschland.
* Preisangaben ohne MWSt. Für Privatkunden kommen 20% österreichische Mehrwertsteuer hinzu.
* U.a. ZeroLogic Logik-Analysatoren.

=== TME (Transfer Multisort Elektronik) ===
Homepage: [http://www.tme.pl/index.phtml?lang=de www.tme.pl]

* Firmensitz in Łódź, Polen
* Zahlungsabwicklung über deutsches Konto
* als Privatkunde: Mehrwertsteuer beachten (22%)
* sehr großes günstiges SMD Sortiment

=== Trade-Shop / AIR Electronics GmbH ===
Homepage: http://www.trade-shop.de

* Trotz knackiger Sprüche auf der englischen Version der Webseite ("Electronic Components Superstore") eher kleines Angebot elektronischer Bauteile
* 20 Euro Mindestbestellmenge (Stand Februar 2008)
* ab 6,90 Euro Versandkosten (Deutschland, bis 1kg) (Stand Februar 2008)

=== Trenkenchu & Stadler GbR ===
Homepage: http://www.ts-audio.de

* die meisten Artikel sind deutlich teurer als der Marktpreis, nur bei exotischen Bauelementen kann man durchaus ein Schnäppchen machen

=== TV-Ersatzteile ===
Homepage: http://www.tversatzteile.de

* TV-, Audio-, Video-Ersatzteile, Aktive / Passive Bauteile
* Fernbedienungen Haushaltstechnik

=== UKW-Berichte ===
Homepage: http://www.ukw-berichte.de

* Antennen, Bauteile, Bausätze, Literatur für Amateurfunk

=== Voelkner ===
Homepage: Kein Link, entsprechend der Vorgabe des Betreibers der Voelkner Webseite im Impressum:
<blockquote>voelkner - direkt günstiger
 
wird produziert und betreut von 
Re-In Retail International GmbH 
... 
Eine Verlinkung auf die Website der Firma Re-In Retail International GmbH bedarf einer schriftlichen Genehmigung. </blockquote>

* Großer Teil des Conrad-Programms, identische Nummern, identische Aufkleber auf der Ware, Preise identisch oder nur ein paar Cent abweichend
* Versandkosten Deutschland: 4,95€; ab 25€ Warenwert und Sofortüberweisung.de versandkostenfrei / Versandkosten-Flatrate für 15€ pro Jahr
* Versandkosten EU: 9,95€
* Möglichkeit der Versandkostenflatrate (D): Einmalig 9,95€ / gültig für ein Jahr
* Legt jeder Bestellung gleich wieder einen Gutschein über 5€ bei MBW 25€ bei (Flat nur bei häufigen, kleinen Bestellungen sinnvoll); außerdem kommt etwa alle 2-3 Monate selbiger Gutschein + versandkostenfreie Lieferung per Mail, ebenfalls MBW 25€
* Verpackungsqualität wechselnd, mal brauchbar, mal eher Pollin-Niveau. Selbst kleine Bestellungen, die gefahrlos per Brief/Großbrief verschickt werden könnten werden in einem großen Paket versendet.

=== VOTI Webshop ===
Homepage: http://www.voti.nl/shop/catalog.html

* relativ kleines Lieferprogramm
* einige interessante Restposten (Surplus)

* Sitz in Amersfoort, Niederlande

=== Walter elektronik ===
Homepage: http://www.walter-elektronik.de

* Bauteile, Röhren

=== Watterott electronic GmbH===
Homepage: http://www.watterott.com

* Distributor für Arduino, BeagleBoard, FriendlyARM, Pololu, Seeed Studio, Solarbotics, SparkFun...vollständige [http://www.watterott.net/about#distri Liste hier]
* Entwicklungskits von Atmel, Luminary Micro, Microchip, Raisonance, TI
* Spezialbauteile von Davicom, FTDI, VLSI, WIZnet
* Bungard Basismaterial + Chemie
* kein Mindestbestellwert
* Zahlung: Vorkasse, Sofortüberweisung, PayPal, Nachnahme, Kreditkarte (Visa/Mastercard), Rechnung (nur gewerbliche Kunden)
* Versandkosten Dtl. (UPS):
** bis 25 EUR Warenwert: 3,50 Euro
** bis 50 EUR Warenwert: 2,90 Euro
** bis 150 EUR Warenwert: 2,00 Euro
** ab 150 EUR Warenwert: versandkostenfrei
* Versandkosten EU (UPS):
** bis 150 EUR Warenwert: 10,00 Euro
** bis 250 EUR Warenwert: 8,90 Euro
** bis 500 EUR Warenwert: 7,00 Euro
** ab 500 EUR Warenwert: versandkostenfrei
* Schneller, entgegenkommender Service

=== Westfalia ===
Homepage Deutschland: http://www.westfalia.de
Homepage Österreich: http://www.westfalia-versand.at

* Vor 85 Jahren in Hagen, Westfalen gegründet
* Elektronik nur ein kleiner Teil des Angebotes. Eher insgesamt Haushalts-, Werkstätten-, Agrar- und Gartenbedarf
* Elektroniksortiment stark schwankend. Momentan (Juni 2008) wenig Auswahl.
* Mindestbestellwert 18 €, bei Neukundenbestellungen mit Prämienanforderungen (wenig wertiges Geschenk) sogar 50 €.
* 4,95€ Versandkosten, ab 150€ Bestellwert versandkostenfrei
* Transportversicherung wird zusätzlich mit einem Zuschlag von 0,8% des Warenwertes berechnet.
* Einmalige Bestellung führte zu jahrelanger Zusendung von Werbung für Westfalia-Angeboten mit Gewinnspielen (Glücksnummern, Rubbellose, Glücksschlüssel, etc.)
* Verpackung ähnlich "sorgfältig" wie bei [[#Pollin_Electronic|Pollin Electronic]]. Übergroße Kartons, wenig Verpackungsmaterial, schweres Teil (Labornetzgerät) flog lose im Karton herum und zertrümmerte andere Ware.

=== WilTec Wildanger Technik GmbH ===
Homepage: http://shop.wiltec.info

* Aoyue Lötgeräte (Heißluft, Löten, Entlöten), Netzteile, Werkzeuge
* Aoyue Zubehör (Lötspitzen, Heißluftdüsen), Ersatzteile
* Andere, nicht Elektronik-Angebote, wie KFZ-Tuningteile
* Versand. Bei Voranmeldung auch Lagerverkauf.

=== Wüstens frag-jan-zuerst ===
Homepage: http://www.die-wuestens.de/dindex.htm

* Röhrentechnik
* Hochspannungs-Spezialteile

=== WIMO ===
Homepage: http://www.wimo.de

* Große Auswahl an Amateurfunktechnik

=== Zech DG0VE ===
Homepage: http://www.dg0ve.de

* Baugruppen für Amateurfunk

=== Diverse ===
* http://www.chip-flip.com - Europäisches Bauelementesuchsystem, franchised Lieferantensuche, Datenblätter und viele nützliche Informationen
* http://www.ecomponents-store.com/ Elektronische Bauelemente kaufen - Hier finden Sie eine große Auswahl an elektronischen und elektromechanischen Bauelementen von über 40 Herstellern.
* http://www.franchised-distributors.eu/ - Finden Sie Vertragsdistributoren von über 800 Halbleiterherstellern für elektronische und elektromechanische Bauelemente.

TODO: elektronik-fundgrube

==Messgeräte ==
=== Neue Messgeräte ===

Viele der oben genannten Elektronikversender verkaufen auch Messgeräte. Darüber hinaus gibt es diverse Versender, die sich hauptsächlich oder ausschließlich auf Messgeräte spezialisiert haben. Allerdings verkaufen viele davon nicht an Privat.

==== CalPlus GmbH ====
Homepage: http://www.calplus.de 
Shop: http://www.scopeshop.de

==== Cosinus ComputerMesstechnik ====
Homepage: http://www.cosinus.de

* Nicht an Privat

==== dataTec ====
Homepage: http://www.datatec.de

* Große Auswahl
* Nicht an Privat

==== Donald4646 ====
Homepage: http://www.donald4646.co.uk

* In Schottland
* Als eBay-Shop gestartet
* Einfache, No-Name und Billigmarken (z. B. Oszilloskope)

==== Elektronik-Kontor Messtechnik GmbH ====
Homepage: http://www.ekomess.de

==== Meilhaus Electronic GmbH ====
Homepage: http://www.meilhaus.de

* Diverse Markenhersteller
* Eigenmarken

==== PinSonne-Elektronik ====
Homepage: http://www.pinsonne-elektronik.de

* Onlineshop
* Sehr kleines Sortiment
* UNI-T, RIGOL und andere asiatische Firmen

==== PK elektronik Poppe GmbH ====
Homepage: http://www.pk-elektronik.de

* U.a. Fluke Distributor.

====Präzitronic Hennig / Messgeräte Chemnitz====
Homepage: http://www.messgeraete-chemnitz.de

* Owon
* Selbst übersetzte deutsche Owon-Handbücher
* Fluke
* Zusätzlich kleines Angebot an Gebrauchtgeräten

==== ScopeShop Hamburg ====

* Von CalPlus übernommen, siehe [[#CalPlus_GmbH|CalPlus]]

==== SI Scientific Instruments GmbH ====
Homepage: http://www.si-scientific.de (Onlineshop) 
Homepage: http://www.si-gmbh.de (komplettes Programm)

* Onlineshop auf si-scientific.de
* Akzeptiert PayPal

==== SKY Messtechnik GmbH ====
Homepage: http://www.sky-messtechnik.de

* Kein Onlineshop (E-Mail oder Telefon)

==== TESTEC ====
Homepage: http://www.testec.info

* Tastköpfe-Hersteller
* Hameg Vertriebspartner
* B+K Precision Generalimporteur

==== Zeitech ====
Homepage: http://zeitech.eu/shop/

* Diverses (Rigol, Owon, etc.)

=== Gebrauchte Messgeräte ===

Dieser Abschnitt enthält Anbieter bei denen gebrauchte Messgeräte erhältlich sind.

==== Astro Electronic ====
Homepage: http://www.astro-electronic.de

==== eumex GmbH ====
Homepage: http://www.eumes.com/pub/de/

* Gebrauchte Messgeräte

==== HTB-Elektronik ====
Homepage: http://www.htb-elektronik.com

* Gebrauchte Messgeräte

==== IX Instrumex ====
Homepage: http://www.instrumex.de/index.cgi?User:LANGUAGE=de

* Gebrauchte Messgeräte

==== Christoph Lüders MessTechnik ====
Homepage: http://www.CLMT.de 
Online-Shop: http://www.shop-016.de/shop-CLMT.html 
eBay: http://myworld.ebay.de/c_h_r/

* Hat 2010 die Restbestände von Förtig übernommen

==== mbmt Messtechnik ====
Homepage: http://www.mbmt.com

* Gebrauchte Messgeräte
* Verkauf nur an Gewerbetreibende

==== Rosenkranz Elektronik ====
Homepage: http://www.rosenkranz-elektronik.de 
eBay Shop: http://stores.ebay.de/Rosenkranz-Elektronik-GmbH-Shop

* Gebrauchte Messgeräte
* Auch auf eBay zu finden

==== Helmut-Singer-Elektronik ====
Homepage: http://www.helmut-singer.de

* Gebrauchte Messgeräte
* Verkauf auch an Privat
* An den meisten Samstagen im Jahr auch Lagerverkauf, sonst Versand

==== Sphere ====
Homepage: http://www.sphere.bc.ca 
Messgeräte und Ersatzteile: http://www.sphere.bc.ca/test/index.html

* Gebrauchte Messgeräte
* Ersatzteile
** Besonders bekannt für Tektronix-Ersatzteile

==== Tektronix TekSelect ====
Homepage: http://www.tek.com/Measurement/tekselect/

* Tektronix verkauft selber gebrauchte und überarbeitete Tektronix-Messgeräte unter dem Label ''TekSelect''.
* Original Tektronix-Garantie
* Der Bestellvorgang nervt, man muss Kontaktaufnahme durch einen "Representative" erbeten.

== Siehe auch ==
* [[Platinenhersteller]]
* [[Lokale Elektroniklieferanten]]
* [[Eisenwarenversender]]

== Links ==

* http://www.xs4all.nl/~ganswijk/chipdir/ Suche nach integrierten Schaltkreisen
* http://www.alldatasheet.com Datenblätter

[[Kategorie:Bauteile|!]]
[[Kategorie:Lieferanten]]

Linksammlung

2011-12-08T16:35:10Z

Mthomas: /* Ungewöhnliche Basteleien (Hacks) */

Auf dieser Seite werden Links zu anderen interessanten Mikrocontroller- und Elektronikseiten gesammelt.
'''
Die alte Linkseite findet man [http://www.mikrocontroller.net/en/links hier].

Hinzufügen von Links:
# [http://www.mikrocontroller.net/wikisoftware/index.php?title=Linksammlung&action=edit Bearbeiten] anklicken
# Link unter der entsprechenden Kategorie eintragen
# "Artikel speichern" klicken

== Suchen & Finden ==

''Verkauf einem hungrigen Mann einen Fisch und du hast ein Geschäft gemacht, bring ihm das Angeln bei und du hast einen Kunden verloren! (asmo)''

* [http://www.supplyframe.com/ SupplyFrame] - Datasheet and Electronic Spec Search Engine
* [http://www.globalspec.com/ GlobalSpec] - The Engineering Search Engine
* [http://www.alldatasheet.com/ alldatasheet] - Datasheet Search
* [http://www.datasheetarchive.com/ datasheetarchive] - Datasheet Search
* [http://www.datasheetcatalog.com/ datasheetcatalog] - Datasheet Search
* [http://www.msarnoff.org/chipdb/ ChipDB] - Pinouts von gängigen µCs.


== [[AVR]] ==

=== Herstellerseiten ===

* [http://www.atmel.com/products/avr/ Atmel.com] Herstellerseiten
* [http://www.atmel.com/dyn/products/product_whatchanged.asp?category_id=163&family_id=607 Atmel.com updates] Liste der letzten Änderungen in Datenblättern und Beispielcode für AVR(8) und AVR32
* [http://www.msc-ge.com/de/produkte/elekom/mc/atmel/avr_start.html AVR Produktinfos] AVR Infos vom Atmel Distributor MSC Vertriebs GmbH

=== Information (Foren, Mailinglisten, Linksammlungen) ===
* [http://progforum.com Batronix Elektronik Forum] Gut besuchtes Forum für allgemeine Elektronik, Mikrocontroller und Programmierung
* [http://www.avrfreaks.net/ AVR Freaks] AVR Forum, Samples, Tutorials, User-Projekte, GCC für AVR (Registrierung empfohlen)
* [http://avr-asm.tripod.com Atmel AVR ASM Site]
* [http://www.mikrocontroller.net Mikrocontroller.net] - AVR Tutorials, Examples, LINKS, Forum (D)


* [http://www.ipass.net/hammill/newavr.htm Atmel AVR Embedded Microcontroller Resources]
* [http://members.tripod.com/Stelios_Cellar/AVR/AVR%20Info.html Stelios Cellar Atmel AVR Info Page] - Samples, Links
* [http://www.elektronik-projekt.de Elektronik Projekt] - Hauptthemen sind AVR und Roboter


* [http://popularmicrocontrollers.com/ AVR Microcontrollers] - A web site about AVR microcontrollers


=== Entwicklungswerkzeuge (Compiler/Assembler/Debugger/Tools/Libraries) ===

==== C ====
* [http://sourceforge.net/projects/winavr WinAVR] (pronounced "whenever") is a suite of executable, open source software development tools for the Atmel AVR series [for the] Windows platform" (includes GNU GCC)
* [http://sourceforge.net/projects/kontrollerlab KontrollerLab] is a free GPL open-source development environment based on KDE, using the avr-gcc, UISP and AVRDUDE
* [http://www.nongnu.org/avr-libc/ avr-libc] avr-gcc's "standard"-library

* [http://hubbard.engr.scu.edu/embedded/avr/avrlib/ Procyon AVRlib] a lot of device drivers and Visual-Studio link for avr-gcc
* [http://rod.info/avr.html rod.info on AVR] esp. for AVR GNU development tools setup under Linux
* [http://www.sisy.de SiSy AVR] - graphische Entwicklungsumgebung mit C/C++ Codegenerierung aus Struktogrammen und Klassendiagrammen
* [http://shop.embedit.de/product__206.php AtmanAVR C/C++ IDE]
* [http://www.iar.com IAR Embedded Workbench]
* [http://www.hpinfotech.com CodeVisionAVR] C-Compiler für AVRs mit Terminal
* [http://www.myAVR.de myAVRWorkpad] kompakte Entwicklungsumgebung für AVRs mit Terminal
* [http://www.amctools.com/vmlab.htm VMLab] komplette IDE mit Debugger und Simulator (auch Peripheriehardware)
* [http://www.forestmoon.com/Software/AvrIoDesigner/ AVR IO Designer] is a utility to generate initialization source code in C/C++ for the various devices, ports and registers of Atmel AVR processors. The intent is to allow the user to explore the devices specific to a selected processor and experiment with settings thru a user interface that assists in understanding the complexities involved. The user can also assign custom variable names to PORT IO pins thereby keeping track of the IO resources in use. These names are emitted in the generated code for use in the user’s program. (Windows .NET 2.0 erforderlich)
* [http://www.piconomic.co.za/avrlib/index.html Piconomic AVRLIB] is a collection of firmware for Atmel AVR microcontrollers. The aim is to share source code, experience and expertise (in the eye of the beholder) with the community of engineers, scientists and enthusiasts.
* [http://www.imagecraft.com/devtools_AVR.html Imagecraft] Der ICCAVR C Compiler fuer AVR von Imagecraft.

==== Assembler ====

* [http://avr-asm.tripod.com Atmel AVR ASM Site]
* [http://www.tavrasm.org/ tavrasm] - Toms Linux (Atmel) AVR Assembler
* [http://www.avr-asm-tutorial.net/gavrasm/index_de.html gavrasm] - Gerds Linux/Win/DOS AVR Assembler
* [http://avra.sourceforge.net/ avra] - avra ATMEL AVR Assembler für Linux, FreeBSD, AmigaOS und Win32
* [http://algrom.net/english.html Algorithm Builder] - graphische Makro-Assembler Entwicklungsumgebung
* [http://www.sisy.de SiSy AVR] - graphische Entwicklungsumgebung mit Assembler Codegenerierung aus Programmablaufplänen
* [http://www.sbprojects.com/sbasm/sbasm.htm SB-Assembler] - Freeware Cross-Assembler unter DOS. (6502, 6800, 6801, 6804, 6805, 6809, 68HC08, 68HC11, Z8, Z80, Z180, 8080, 8085, 8021, 8041, 8048, 8051, AVR, PIC1684,...)
* [http://www.myAVR.de myAVRWorkpad] kompakte Entwicklungsumgebung für AVRs mit Terminal
* [http://john.ccac.rwth-aachen.de:8000/as/ Macro Assembler AS] - AS is a portable macro cross assembler for a variety of microprocessors and -controllers
* [http://shop-pdp.kent.edu/ashtml/asxxxx.htm ASxxxx Cross Assemblers] - The ASxxxx assemblers are a series of microprocessor assemblers written in the C programming language. (1802, S2650, C/MP, MSP430, 61860, 6500, 6800(6802/6808), 6801(6803/HD6303), 6804, 6805, 68HC(S)08, 6809, 68HC11, 68HC(S)12, 68HC16, 740, 8048(8041/8022/8021) 8051, 8085(8080), DS8xCxxx, AVR, Z80, F2MC8L/FX, GameBoy(Z80), H8/3xx, Cypress PSoC(M8C), PIC, Rabbit 2000/3000, Z8, Z80(HD64180)) linux & windows, source code

==== Disassembler ====

* [http://www.datarescue.com/idabase/ IDA-Pro] -Disassembler und Debugger für fast alle bekannten Prozessoren. Evaluation Version verfügbar. Tagline: ''The most advanced tool for Hostile Code Analysis, Vulnerability and Software Reverse Engineering''
* [http://www.jassenbaum.de/ja-tools/ ReAVR] - Disassembler und ACXutility Binary Tool
* [http://www.visi.com/~dwinker/revava/ revava] - Disassembler
* [http://dev.frozeneskimo.com/software_projects/vavrdisasm vAVRdisasm] - Free AVR Disassembler
* [http://www.johannes-bauer.com/mcus/avrdisas/ avrdisas] - AVR Mikrocontroller Disassembler für Linux (und Win32)


==== BASIC ====
* [http://www.mcselec.com/bascom-avr.htm Bascom AVR]
* [http://www.fastavr.com FastAVR] - und mit 'ASM' Ausgabe, Nokia3310 LCD Unterstützung
* [http://www.nettypes.de/mbasic mikrocontrollerBASIC Freeware] - mit Simulator für ATmega32, ATmega128 und C-CONTROL.
* [http://www.mikroe.com/en/compilers/mikrobasic/avr/ mikroBasic] - Comprehensive, stand-alone Basic compiler for AVR microcontrollers
* [http://home.arcor.de/EDAconsult/Page3/index.html?c~3.1 MCS BASIC-52] - Original-Übersetzung 1988 INTEL MCS BASIC-52 USERS MANUAL 220 Seiten frei Download als PDF
* [http://www.DieProjektseite.de Beetle-Basic] Leistungsfähiges Basic-Betriebssystem im AVR.
* [http://www.mikrocontroller.net/articles/AVR_BASIC AVR_BASIC] Open Source Freeware: Minimalistischer Basic-Interpreter im AVR.
* [http://gcbasic.sourceforge.net/ Great Cow BASIC] "Open Source BASIC programming tools for Microchip PIC and Atmel AVR microcontrollers"

==== Pascal ====
* [http://www.e-lab.de AVRco Pascal Compiler] - AVR Pascal Compiler mit umfangreicher Funktionslibrary
* [http://www.mikroe.com/en/compilers/mikropascal/avr/ mikroPascal] - Comprehensive, stand-alone Pascal compiler for AVR microcontrollers

==== Forth ====
* [http://www.robo-forth.de www.robo-forth.de] - AVR Forth Compiler mit umfangreicher Funktionslibrary für Servos, Motore und Sensoren
* [http://amforth.sourceforge.net/ amforth] - Forth for Atmel ATmega micro controllers von Matthias Trute. [http://www.mikrocontroller.net/topic/55807#430816 Diskussion]

==== Java ====
* [http://www.harbaum.org/till/nanovm NanoVM] - Java VM für AVR-Mikrocontroller ([[NanoVM|deutsches Wiki]])
* [http://www.fam-frenz.de/stefan/compiler.html SJC] - Java-Compiler (erzeugt AVR-Maschinencode) für AVR-Mikrocontroller ([[SJC]])

==== Ada ====
* [http://avr-ada.sourceforge.net/ AVR-Ada] - Ada Compiler innerhalb von GCC (GNAT) für AVR. Enthält eine kleine Laufzeitbibliothek ohne Tasking und ohne Exceptions. [http://www.mikrocontroller.net/topic/168823#1614208]

==== Virgil ====
* [http://compilers.cs.ucla.edu/virgil/index.html The Virgil Programming Language] is designed for building robust, flexible, and scalable software systems on embedded hardware platforms. Virgil builds on ideas from object-oriented, statically typed languages like Java, providing a clean, consistent source language. Its compiler system provides an efficient implementation for resource-constrained environments.

==== LabVIEW ====
* http://www.ni.com/embedded/ Informationen zu LabVIEW, der graphischen Entwicklungsumgebung von National Instruments
* http://www.labviewforum.de/ Deutsches Labview-Forum
* [http://web.me.com/iklln6/automation/LabVIEW.html Communicating Arduino-->LabVIEW]

==== Python ====
* [http://code.google.com/p/python-on-a-chip/ python-on-a-chip] (pymite). There are two sample projects in the source tree. One for an 8-bit Atmel ATmega103 (but any AVR/ATmega with 4 KB RAM or more will do) and one for the 32-bit Atmel AT91SAM7S64 running on the AT91SAM7S-EK evaluation board. (GPL Lizenz)

==== Openeye ====

* OpenEye ist eine Kombination aus PC-Programm (Windows, Delphi) und einer Monitor-Routine im AVR. Die Daten aus dem AVR werden mit RS232 übertragen und können fürs Debuggen der laufenden Anwendung benutzt werden. OpenEye wurde vom User Martin Vogel (oldmax) geschrieben [http://www.mikrocontroller.net/topic/143144#1326244].

==== Modkit ====

[http://blog.modk.it/ Modkit] is a new kind of graphical programming environment that makes programming things in the physical world as easy as dragging and dropping little virtual code blocks in a web browser.. Heavily inspired by the Scratch programming environment (from MIT Media Lab's Lifelong Kindergarten Group), Modkit enables anyone including kids, artists and inventors to build with electronic kits and components including motors, sensors, lights, sound and the popular Arduino and Arduino compatible development boards... (Text vom Makezine)

=== Tutorials und Beispiele ===

* [http://www.meinemullemaus.de/elektronik/avr_workshop/index.html AVR Mikrocontroller] Einfühung in AVR Mikrocontroller mit Nachbau des Spiels "Senso".
* [http://www.avrbeginners.net AVRBeginners.net] Beginners Guides to AVRs
* [http://www.wikidorf.de/reintechnisch/Inhalt/AVRProjekt-9V-LED-Lampe reintechnisch.de] AVR Tutorial: 9V-LED-Lampe
* [http://www.schaltungsforum.de Das Schaltungsforum] ist eine Seite für Anfänger und Profis welche ständig mit Tutorials erweitert wird. Stellt Eure Projekte online. Die Seite befindet noch im Aufbau und Eure Mithilfe ist erwünscht.
* [http://www.mikrocontrollerspielwiese.de mikrocontrollerspielwiese.de] ist eine Seite, die an Anfänger gerichtet ist und Experimente und fertige Projekte komplett mit Code und Eagle-Dokumenten zur Verfügung stellt.
* [http://www.elo-web.de/elo/mikrocontroller-und-programmierung/avr-anwendungen ELO-AVR-Anwendungen] bietet eine wachsende Sammlung kleinerer AVR-Projekte, überwiegend für die ATTiny-Serie.
* [http://www.schramm-software.de/tipps/ AVR-Tipps] Programmier-Tipps und AVR-Experimente.
* [http://www.uwe-kerwien.de/pll/pll-synthesizer.htm PLL-Synthesizer Tutorial] kleines praxisorientiertes PLL-Tutorial zur Funktion, Reparatur und Steuerung einer PLL-Schaltung mit AVR ATtiny2313 über 3-Leiter-Bus
* Arduino
** [http://tronixstuff.wordpress.com/tutorials/ t r o n i x s t u f f] - Arduino Tutorials (engl.)
** [http://www.earthshinedesign.co.uk/ASKManual/Site/ASKManual.html The Complete Beginners Guide to the Arduino]
** [http://www.codeproject.com/KB/system/ArduinoVB.aspx Arduino with Visual Basic] by Carl Morey auf codeproject.com

==== C ====
* [[AVR-GCC-Tutorial]]
* [http://www.smileymicros.com/QuickStartGuide.pdf Quick Start Guide for using the WinAVR Compiler with ATMEL's AVR Butterfly] ([http://www.smileymicros.com www.smileymicros.com], PDF)
* [http://www.avrtutor.com/tutorial/thermo/contents.htm avrtutor] - an attempt to provide a real tutorial for the ATMEL AVR microcontrollers.
* [http://www.sparkfun.com/commerce/present.php?p=BEE-1-PowerSupply Spark Fun Electronics] - Beginning Embedded Electronics (Atmega8, englisch)
* [http://metku.net/index.html?path=articles/microcontroller-part-1/index_eng metku.net] - How to get started with microcontrollers (ATtiny45, Steckbrett)
* [http://www.stromflo.de/dokuwiki/doku.php?id=xmega-c-tutorial XMEGA-C-Tutorial] - Tutorial über Atxmega

==== Assembler ====
* [http://avr-asm.tripod.com Atmel AVR ASM Site]
* [http://www.avr-asm-tutorial.net Atmel AVR Microcontroller Assembler Tutorial] (D)
* [[AVR-Studio]]

==== Bascom ====
* [http://www.mcselec.com/ MCS Elektronik] BASCOM AVR Demo zum Download

==== Pascal ====
* [http://www.elektronik-projekt.de/content/download/avrco_tut2.pdf AVRco Pascal Tutorial] - von Markus
* [http://www.ibrtses.com/embedded/avr.html ein paar Seiten zum AVR] (ASM und Pascal) von ibrt

==== Ada ====
* [http://sourceforge.net/apps/mediawiki/avr-ada/index.php?title=Tutorial AVR-Ada Tutorial]

=== Hardware (Prototypen-Platinen-Boards etc.) ===

* [http://retrodan.tripod.com Atmel AVR Butterfly Site]
* [http://www.kanda.com Kanda] Starter Kits and Development Tools for different Microcontrollers
* [http://www.dontronics.com Dontronics] Starter Kits and Development Tools for different Microcontrollers, Linkpages for AVR and PIC
* [http://www.mikrocontroller.com mikrocontroller.com] u.a. Platine AVR-Ctrl, AVR-Webserver (D)
* [http://mikrocontroller.cco-ev.de/eng/ AVR webserver] RTL8019, 3COM (E)
* [http://www.microcontroller-starterkits.de Microcontroller-Starterkits] Starter Kits for different Microcontrollers (D)
* [http://www.olimex.com Olimex Ltd.] DevelopmentBoards and Tools
* [http://www.krause-robotik.de Krause Robotik] Controller Boards & Zubehör
* [http://www.robotikhardware.de robotikhardware.de] Controller Boards
* [http://www.embedded-it.de/microcontroller/microcontroller-module.php Embedded-IT] USB Module auf AVR Basis sowie Ethernut kompatible Embedded Ethernet Mikrocontroller Boards für Industrie und Hobby auf ARM mit Nut/OS Betriebssystem
* [http://www.ssv-embedded.de SSV Embedded Systems] 32-bit Mikrocontrollermodule und -boards, Starter Kits etc.
* [http://shop.embedit.de/browse_002_21__.php Embedit] Mikrocontrollermodule und -boards
* [http://www.display3000.com Display3000] Farbdisplays, Mikrocontrollermodule und -boards mit TFT-Farbdisplays; Experimentierplatinen und Ansteuerplatinen für TFT Farbdisplays
* [http://www.myavr.de myAVR] Einsteigerboards und Zubehör
* [http://www.siphec.com/ SIPHEC] Development Boards für AVR, MSP430, USB
* [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MTY5OTgxOTk=&w=OTk4OTY4&ts=0 ATMEL Evaluations-Board Bausatz] ([http://www.pollin.de/shop/downloads/D810038B.PDF PDF]) und [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MzU5OTgxOTk=&w=OTk4OTY4&ts=0 ATMEL Funk-Evaluations-Board Bausatz] ([http://www.pollin.de/shop/downloads/D810046B.PDF PDF]) von Pollin
* [http://www.lochraster.org/etherrape/ Etherrape] Atmaga 644 mit Ethernet und TCP/IP als Bausatz.
* [http://www.ic-board.de/index.php?cat=c4_Programmer.html AVR Programmieradapter],[http://www.ic-board.de/index.php?cat=c3_Funkmodule.html ZigBee-ready Funkmodule/Funk-USB-Sticks] und [http://www.ic-board.de/index.php?cat=c13_ICradio-Bundles.html Funk Starterkits] von In-Circuit
* [http://www.ic-board.de/index.php?cat=c2_ICnova-Module.html AVR32 AP7000 Linux Board] mit 2xEthernet, TFT, Audio, SDCARD, USB-Host/Devive, Funk...
* [http://www.das-labor.org/wiki/Laborboard Das Laborboard] von das-labor.org (DIY)
* [http://six.media.mit.edu:8080/6 number six] - Open Source Design, Atmega32. Alle Pins sind auf eine 2x20 Pol Wannenstiftleiste herausgeführt.
* http://www.maares.de/tools USB Memory Stick am AVR Butterfly. AVR Butterfly Trägerplatine zum Anschluß von VDRIVE, VMUSIC, RFM12.
* [http://www.wiring.org.co/ Wiring] is an open source programming environment and electronics i/o board for exploring the electronic arts, tangible media, teaching and learning computer programming and prototyping with electronics.
* [http://www.chip45.com/ chip45] Atmel AVR Module und Boards mit USB, RS232/485, CAN, Ethernet, Funkmodule, sowie ISP Programmieradapter.
* [http://www.rakers.de/catalog Dr. Rakers] AVR Boards und Experimentierplatinen mit USB, Ethernet, RS232, CAN, LCD etc. in hochwertiger Qualität zu günstigen Preisen.
* [http://nibo.nicai-systems.de Roboterbausatz Nibo] - autonomer Roboter mit einem ATmega128 und einem ATmega88
* [http://www.aevum-mechatronik.de Modularis] - AVR Mikrocontroller-Boards (z.T. mit Zusatz-Speicher und USB) die über Flachbandkabel erweitert werden können. Es gibt bis jetzt Zubehör-Module mit Taster, Motor H-Brücke, XBee und Winkelsensor.
* [http://www.schramm-software.de/bausatz/ Schramm-Software] - AVR Mikrocontroller-Bausätze
* [http://www.alvidi.de/ Alvidi] - Headerboards mit AVR & AVR32 Controllern
* [http://www.steitec.net/ Steinert Technologies] - Thailändischer Anbieter von Mikrocontroller Boards (AVR, ARM7, ARM9, PIC, dsPIC, PSoC, uvm.)
* Arduino
** [http://www.arduino.cc/ Arduino] Homepage
** [http://www.freeduino.org/ Freeduino.org] - Riesige Linksammlung zu dem '''Ardunio'''(R) AVR-Board (Kit) und dessen Clones und Mutanten (DIY oder Kit)
** [http://www.freeduino.de/ freeduino.de] - Anleitungen und Tutorials, Arduino Wiki, Blog, Tools in Deutsch
** [http://shieldlist.org/ Arduino Shield List]
* [http://www.fritzing.org Fritzing] nützliches Programm für viele Betriebsysteme zur Unterstützung eines Brettboard-Aufbaus(ungetestet).
* [http://www.specialprint.eu Specialprint] InkjetDruck für den digitalen Direktdruck von Ätzmasken, Lötstoppmasken, Frontplatten, Kennzeichnungen
* [http://www.onlinesteuerung.de Onlinesteuerung.de] USB Bausatz. Technische Geräte per PC, Browser, Netzwerk, Ethernet, TCP/IP, Internet, Excel, Timer oder Sensoren schalten.
* [http://8devices.com/product/3/wi-fi-4-things Carambola WiFi module] Open hardware Linux friendly (OpenWRT) WiFi 802.11n OEM module
* [http://www.atxmega-board.de ATxMegaBoard und ATxMegaStick] Entwicklungsboards, zum Einstig in die Welt der ATxMegas

=== Programmierhard- und Software ===
* [http://www.obdev.at/products/avrusb/avrdoper.html AVR-Doper] Einfach nachzubauender, STK500-kompatibler Programmer mit USB-Anschluss. Beherrscht auch HVSP, nicht jedoch HVPP. Open Source.
* [http://www.bsdhome.com/avrdude/ AVRDUDE] AVR ISP-Programmerierwerkzeug für Unix/Linux/BSD und Windows. Kommandozeile [http://sourceforge.net/projects/avrdude-gui/ (oder mit GUI)], AVR Butterfly-Unterstützung
* [http://www.lancos.com/prog.html PonyProg] neben AVR für diverse seriell programmierbare Bauteile (Grafische Nutzeroberfläche und Kommandozeile), siehe auch [[Pony-Prog Tutorial]]
* [http://savannah.nongnu.org/projects/uisp/ uisp] AVR ISP-Programmierwerkzeug für Unix/Linux/BSD und Windows (Kommandozeile)
* [http://www.myplace.nu/avr/yaap/ yaap]
* [http://www.xs4all.nl/~sbolt/e-index.html SP12]
* [http://www.mikrocontroller-projekte.de/Mikrocontroller/AVR-Prog/AVR-Programmer.html AVR910 kompatibler Programmer] mit aktueller, beschleunigter Firmware.
* [http://www.der-hammer.info/hvprog STK500 kompatibler Programmer] als Nachbauprojekt. Siehe auch [[STK500]]
* [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=73&products_id=41 Preiswerter Standard ISP (STK200 kompatibel)]
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/evertool/ Evertool] kombinierter ISP & [[JTAG]] Programmer (kompatibel zum "original" Atmel AVRISP und Atmel JTAGICE)
* [http://www.olimex.com Olimex] (Bulgarischer Anbieter) Kostengünstig
* [http://www.avr-projekte.de/isp.htm AVR910-USB Programmer] incl. USB-Modul und USB->Seriell Wandler
*[http://www.fischl.de/usbasp/ USBasp] – USB-Programmer bestehend aus ATmega8 (kein spezieller USB-Chip notwendig)
* [http://home.arcor.de/bernhard.michelis Amadeus-USB] - Highspeed-Programmer für PIC18, PIC24, dsPIC30, PIC32, dsPIC33 und AVR. Bietet auch Möglichkeiten zur Fehlersuche.
* [http://www.e-dsp.com Signalgenerator] - Signalgenerator software
* [http://www.piketec.com/products/tpt.php Time Partition Testing (TPT)] - Test-, und Testauswertewerkzeug für eingebettete Systeme
* [http://shop.myavr.de/Programmer.htm?sp=artlist_kat.sp.php&katID=16 mySmartUSB] - USB Programmer (ab 15€) kombiniert auch mit USB-UART-Bridge, STK500v2/AVR910/AVR911 kompatibel, ISP HV-seriell, HV-parallel
* [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=73&products_id=161 USB-Programmer für Bascom Programmierer]
* [http://www.virtualserialport.com/ Virtual Serial Port] Software for serial port communication and null-modem emulation
* [http://www.ic-board.de/index.php?cat=c4_Programmer.html AVR Programmieradapter und JTAGICE MKII]
* [http://www.helmix.at/hapsim/index.htm HAPSIM graphischer Simulator ] zu graphischen Simulation von Tasten /LED /LCD und Terminal in AVR Studio Freeware !!!
* [http://www.ic-board.de/index.php?cat=c4_Programmer.html AVR Programmieradapter und JTAGICE MKII]
* [http://www.myavr.de/download.php?suchwort=ProgTool myAVR ProgTool] nette Programmieroberfläche (free)
* [http://b9.com/elect/avr/kavrcalc/ KAVRCalc] is a free calculator to assist in programming AVR microcontrollers (Baudrate, Watchdog, Timer, ...)
* [http://www.chip45.com/CrispAVR-USB CrispAVR-USB] STK500 V2 kompatibler ISP Adapter mit USB Schnittstelle für Atmel AVR Mikrocontroller (1,8V-5,5V).
* [http://ucom-ir.nicai-systems.de UCOM-IR] - Programmieradapter mit USB Schnittstelle (AT90USB162) und IR-Sender/Empfänger, STK500 V2 kompatibel
* [http://www.anagate.de/products/programmers.htm AnaGate Programmer] Serielle Programmer mit LAN-Anschluss für I2C und SPI inkl. Programmier-API für Windows/Linux (Shop)

=== Projekte und Quellcodebibliotheken ===

====Bibliotheken====
* [http://www.nongnu.org/avr-libc/ AVR Libc]
* [http://hubbard.engr.scu.edu/embedded/avr/avrlib/docs/html/index.html Procyon AVRlib]
* [http://homepage.hispeed.ch/peterfleury Peter Fleury's Pages] - UART / LCD (HD44780) / I²C (TWI)/ AVR-GCC Bibliotheken, STK500v2 Bootloader
*[http://sourceforge.net/projects/avrfix Fixed Point Library Based on ISO/IEC Standard DTR 18037 for Atmel AVR microcontrollers, u.a. Cordic-Algorithmen] und [http://www.enti.it.uc3m.es/wises07/presentations/session2/05%20-%20Fixed%20Point%20Library%20According%20to%20ISOIEC%20Standard%20DTR%2018037%20for%20Atmel%20AVR%20ProcessorsWISES07-fixedpointlibrary%20-%20Elmenreich.pdf Kurzbeschreibung dazu als Powerpoint-PDF TU Wien Febr. 2007]

==== Betriebssysteme & Co. ====
* [http://www.tinyos.net/ TinyOS] - Komponentenbasiertes Betriebssystem für Sensorknoten. Bringt eigene C-ähnliche Hochsprache nesC mit.
* [http://www.chris.obyrne.com/yavrtos/ YAVRTOS] - Yet Another Atmel® AVR® Real-Time Operating System von Chris O'Byrne (C, Atmega32, GPL3 Lizenz)
* [http://www.freertos.org/ FreeRTOS] is a portable, open source, mini Real Time Kernel - a free to download and royalty free RTOS that can be used in commercial applications. (AVR, MSP430, PIC, ARM7, ...)
* [http://www.barello.net/avrx/index.htm AvrX Real Time Kernel] (IAR ASM oder IAR/GCC C, GPL2 Lizenz)
* [http://scmrtos.sourceforge.net/ scmRTOS] - Single-Chip Microcontroller Real-Time Operating System (C++, AVR, MSP430, Blackfin, ARM7, FR (Fujitsu, [http://www.opensource.org/licenses/mit-license.php MIT Lizenz]).
* [http://www.circuitcellar.com/avr2004/DA3650.html csRTOS] - cooperative single-stack RTOS aus dem Circuit Cellar AVR 2004 Design Contest. [http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_id=987&item_type=project csRTOS port to ATmega32] und [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=50743&start=all&postdays=0&postorder=asc Diskussion] auf www.avrfreaks.net führte zur Weiterentwicklung als [http://www.mtcnet.net/~henryvm/4AvrOS/ 4AvrOS] - cooperative scheduler
* [http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_type=project&item_id=230 OPEX] - freeware cooperative scheduler with lots of calendar and I/O functions von Steve Childress (Download auf www.avrfreaks.net ggf. Registrierung notwendig)
* [http://www.mikrocontroller.net/topic/12176#79672 Scheduler] von Peter Dannegger
* [http://www.mikrocontroller.net/topic/25087#186454 RTC-Scheduler] von ape
* [http://www.sics.se/~adam/pt/ Protothreads] - Lightweight, Stackless Threads in C (open source BSD-style license)
* [http://www.micrium.com/products/rtos/kernel/rtos.html uC/OS-II] is a real time operating system developed by Jean J. Labrosse. You can obtain the source code for the OS by buying Labrosse's excellent book ''MicroC/OS-II The Real-Time Kernel (2nd edition)''. [http://www.ee.lut.fi/staff/Julius.Luukko/ucos-ii/avr/index.shtml Port for AVR (gcc 3.x)] and [http://www.myplace.nu/avr/ucos/index.htm AVR (gcc 2.x)].
* [http://freshmeat.net/projects/qp/ QP] is a lightweight, portable framework/RTOS for embedded systems (ARM, Cortex-M3, 8051, AVR, MSP430, M16C, HC08, NiosII, and x86). GPL (und kommerzielle Lizenz verfügbar)
* [http://www.femtoos.org/ Femto OS] von Ruud Vlaming ist ein preemptives Betriebssystem für die kleinsten Mikrocontroller aus der AVR Serie bis ca. 16 KB ROM und 1 KB RAM. Spezielle Targets sind: ATtiny861/461/261. Geschrieben in C. Freie Software, GPLv3. Artikel in Elektor Februar 2010
* [http://www.projects-lab.com/?p=344 kaOS] is a real-time, multithreaded, preemptive operating system for the ATmega32 microcontroller, which loads and executes programs from a Secure Digital or MMC card. Authors Nicholas Clark & Adam Liechty. (Circuit Cellar AVR Wettbewerb 2006)
* [http://helium.sourceforge.net/ Helium] is a minimalistic real-time kernel for the HC(S)08 core by Freescale and Atmel AVR.
* [http://dev.bertos.org/ BeRTOS] is a completely free, open source, real time operating system (RTOS) suitable for embedded platforms. Runs on many microprocessors and microcontrollers, ranging from 8 bits to 32 bits CPUs and even PCs.
* [http://funkos.sourceforge.net/ funkos] Targets: AVR, XMEGA, MSP430, Cortex M3, Open Source
* Vergleich zwischen [http://antipastohw.blogspot.com/2009/11/4-operating-systems-for-arduino.html 4 Operating Systems for the Arduino] auf [http://antipastohw.blogspot.com Liquidware Antipasto]
** '''DuinOS''' by RobotGroup (FreeRTOS Portierung)
** [http://www.skewworks.com/pyxis/ Pyxis OS] by ArduinoWill
** '''ArduinoMacOS''' by Mark
** '''TaOS''' by Ziplock
* [http://atomthreads.com/ Atomthreads] is a free, lightweight, portable, real-time scheduler for embedded systems. (BSD Lizenz)
* [http://www.shift-right.com/xmk/ XMK] (eXtreme Minimal Kernel) ist ein freies Echtzeitbetriebssystem für Mikrocontroller (AVR, H8, R8C, M16C).
* [http://irtos.sourceforge.net/index.html.en iRTOS] is an free Real Time Operating System. The iRTOS kernel is free to download and use under the terms of LGPL. It can be used in commercial applications. iRTOS is designed for tiny 8 bit microconroller chips with little RAM usage. OS can be installed also in 16 and 32 bit processor units.
* [http://sites.google.com/site/cocoosorg/avr-projects/home cocoOS] is a cooperative task scheduler, based on coroutines and it is written in C. (STK500, Atmega16)
* [http://www.DieProjektseite.de BasicBeetle] Basic-Betriebssystem im AVR
* Shells für Arduino:
** [http://biot.com/arsh/ ARSH]
** [http://www.battledroids.net/downloads/avrsh.html AVRSH]
** [http://bitlash.net/wiki/start BITLASH]
** [http://sourceforge.net/projects/fruitshell/ FRUITSHELL]
** [http://www.gisvold.co.uk/~gisvold/drupal/node/1484 BREAKFAST]
* [http://nootropicdesign.com/toolduino/ toolduino] is a simple software tool that lets you easily interact with your Arduino hardware so you can test the circuits you create. Toolduino is written in the [http://processing.org/ Processing] languange and is available for Windows, Mac OS X, and Linux. Toolduino uses the the [http://www.arduino.cc/playground/Interfacing/Processing Arduino library for Processing] to communicate with an Arduino board so you can manipulate output pins and read inputs. The Arduino must be running the [http://firmata.org/wiki/Main_Page Firmata] firmware that comes with the Arduino IDE. (LGPL)
* [http://www.mueller-torres.de/avr.php MOPS] - A small C and Assembly based operating system for the ATMEL AVR® 8-Bit RISC controller family.
* [http://www.hk-businessconsulting.de/rts.htm RTS(Realtime Tasking System)] - Betriebssystemkern mit Echtzeiteigenschaften, Lizenz: EUPL V. 1.1

==== Projektsammlungen ====

* [http://www.DieProjektseite.de Die Elektronik-Projektseite und Heimat des BasicBeetle] Hauptthema ist der BasicBeetle. Ein modularer, leistungsfähiger, in Basic programmierbarer Mikrorechner speziell für Steuerungen. Mit vielen Programmen, Tiipps und Tricks, Informationen...
* [http://www.Happy-Micro.de Happy-Micro.de] Die Internetsite für Hobbyelektroniker, Mikrocontroller-Anwender, Programmierer und alle, die Spaß an Computern und Elektronik haben. Bei Happy-Micro.de steht der Spaß am Entwickeln von Programmen und Schaltungen im Vordergrund. Jeder Benutzer hat die Möglichkeit auch als Autor mitzumachen und seine Schaltungen oder Programme zu veröffentlichen. Freier Bilderdownload für die eigene Homepage. ''(Seite wurde geschlossen!)''
* [http://iwenzo.de Elektronik und Informationen] Wissenswertes aus der Unterhaltungselektronik..
* [http://instruct1.cit.cornell.edu/courses/ee476/FinalProjects/ Cornell University ECE 476 Microcontroller Design Final Projects]
* [http://www.serasidis.gr/ Serasidis Vasilis' AVRsite] u.a. GLCD, SMS, PAL
* [http://www.riccibitti.com Alberto Ricci Bitti] u.a. PAL Video-Interface
* [http://www.ulrichradig.de Mikrocontroller and more] AVR - Projekte (Ethernet, LCD, Relaiskarte usw.) und mehr
* [http://home.arcor.de/burkhard-john/index.html Burkhard John] (D)
* [http://www.avrprojects.net/ AVRmicrocontrollerprojects] u.a. Text-LCD, Schrittmotor, Thermometer
* [http://hem.bredband.net/robinstridh/ Robin Stridh] Rotor-Anzeige, Video-Interface
* [http://www.dertien.dds.nl/content/avrprojects.html dertien.dds.nl AVR-Projects]
* [http://www.microsps.com MicroSPS.com] Grafische Programmierung des AVR mit EAGLE
* [http://www.h-mpeg.de h-mpeg Festplatten mp3 Player] IDE Ansteuerung, IDE Filesystem, LCD Ansteuerung etc. in 8K Code. Quelltext unter GPL
* [http://www.embedtronics.com/ embedtronics.com]
* [http://www.siwawi.arubi.uni-kl.de/avr_projects M. Thomas' AVR Projekte] untern Anderem AVR Butterfly avr-gcc-port, DB101 gcc-port, BC100 gcc-port, Bootloader, Programmier- und Debughardware, Software-UART, DS1820-Lib., experimentelle avrdude-Versionen, AVR und CAN mit MCP2515 
* [http://www.mictronics.de Michaels Electronic Projects] AVR Projekte (EN) - ua. Sony/Becker CD/MD Wechsler Emulator, RDS-Decoder, GPS Infos, OBD J1850 VPW Interface, USB<>CAN Bus Interface. Informationen zu CD Wechsler Protokollen. MP3stick - MP3 Player mit ATmega128, color LCD, SD/MMC Karte und VS1011b
* [http://www.stahlbucht.de/elektronik/node13/ node13] modulares AVR 8515 Projekt: eine Controller-Platine, an die sich weitere Ein-Ausgabemodule (Tastenfeld, LEDs, LCD-Modul) anschliessen lassen
* [http://www.mikrocontroller-projekte.de www.mikrocontroller-projekte.de] Diverse Projekte mit AVR Controllern. AVR910 Programmer, Testboard und Modellbauelektronik
* [http://www.roboternetz.de/phpBB2 Roboternetz-Mikrocontroller Projekte.de] Diverse Projekte mit AVR und anderen Controllern, insbesondere im Bereich Robotik
* [http://www.avr-projekte.de AVR-Projekte.de] Belichtungstimer, FT232RL Schaltungen,LED-Fading über Fernbedienung, HD44780-LCD über USB und Seriell, AVR910-USB Programmer, Basteleien: Ätzmaschine,Kompressor.
* [http://openeeg.sourceforge.net/ openeeg.sourceforge.net] Das OpenEEG Projekt befasst sich mit der Entwicklung eines preiswerten Elektro-Enzephalographie (EEG) Geräts und dessen freier Steuersoftware zur Messung elektrischer Gehirnströme. Sein µPC-Herz ist ein AT90S4433 bzw. ein ATmega8. Ziel sind auch verschiedene EEG Anwendungen z. B. im Bereich mentaler Trainingsmethoden (Neurofeedback).
* [http://www.amateurfunkbasteln.de/ www.amateurfunkbasteln.de] Seite von Michael Wöste (DL1DMW) u.a. CPU-Board mit AT89C2051, AT89C4051 oder AVR AT90S2313, CPU-Board mit Atmel AT90S8535, Experimentierplatine mit ATmega103, Programmer für AT89C2051/AT89C4051, 32-Kanal-Logik-Analysator bis 40 MHz (Entwurf von David L. Jones)
* [http://www.atmel.com/dyn/products/app_notes.asp?family_id=607 Atmel - AVR 8-Bit RISC - Application Notes] Anwendungshinweise und Beispiele vom Hersteller
* [http://www.projects.cappels.org/ Dick Cappels' Project Pages]
* [http://see-by-touch.sourceforge.net/index.html SeebyTouch - Blinden-Seh-Ersatzsystem] Computerbilder fühlen durch ein einfaches Gerät (Bauanleitung) und freier Software (für 10 Betriebssysteme) - eine neue Erfahrung für alle
* [http://www.loetstelle.net www.loetstelle.net] Verschiedene kleinere AVR-Projekte rund um LEDs, z. B. RGB Dimmer, Moodlight. Diverse Elektronikprojekte und Grundlagen
* [http://www.dietmar-weisser.de Selbstbauprojekte Elektronik] kleine Sammlung von Elektronikprojekten zum Thema Leiterplattenfertigung, Hochfrequenztechnik und Mikrocontroller.
* [http://www.myplace.nu/avr/ Jesper's AVR pages] Yampp MP3 Player, Yaap Programmer, DDS mit 2313+R2R, Gitarrentuner, Frequenzzähler.
* [http://www.microsyl.com/ MicroSyl MCU] MP3 Player, MegaLoad, HCLoad, Propeller Clock, Freq Meter, BarCode Reader, Door Bell, OneWire Lib, Text LCD Lib, Graph LCD Lib, Nokia LCD Lib, Led Sign with MMC MemoryCard, Intercom
* [http://www.jeroen.homeunix.net/ http://www.jeroen.homeunix.net/] Aufbau eines elektronischen Rouletts auf basis eines AVRs
* [http://thomaspfeifer.net thomaspfeifer.net] Reflow-Ofen, Laminator-Temperaturregelung, USB-Atmel-Programmer, SMD-Tricks u.v.m.
* [http://www.scienceprog.com Scienceprog - embedded theory and projects] - AVR, ARM theory and projects
* [http://www.iuse.org Hausautomatisierung] - CAN-Bus mit ATmega32-Controllern und Bedienfeldern, Admin-Tools zum Updaten via CAN, Traffic Dumper etc.
* [http://www.myevertool.de AVRSAM] - AT91SAM7S Header Board annährend 100% Pinkompatibel zu den folgenden AVR Mikrocontroller: AT90S8535 / ATMEGA8535 / ATMEGA16 / ATMEGA32
* [http://members.aon.at/hausbus Hausbus Home] - Hausbus-Projekt unter Verwendung von ATmega8, ATtiny13 und ATmega128
* [http://www.thomas-wedemeyer.de/elektronik/AVR/avr-dcf-clock.html AVR-DCF-Clock] - DCF-Uhr mit bunter LED-Anzeige - ATmega8
* [http://www.grasbon.de/genuhr.html GenuhR] - DCF-Funkuhr / Wecker/ Timer mit LED-Punktmatrixanzeige. Das Projekt beschreibt den Aufbau des kompletten Gerätes beginnend beim Schaltplan bis hin zur Montage in ein Gehäuse.
* [http://www.avrguide.com/ AVR Projektsammlung] bei www.avrguide.com
* AVR Synth http://www.elby-designs.com/avrsynth/avrsyn-about.htm http://www.jarek-synth.strona.pl/
* [http://elm-chan.org/he_e.html Electronic Lives Manufacturing] - Aufbauten in Fädeldrahttechnik, tlw. auf Japanisch, aber mit englischen Sourcecodes
* AVR Synthesizer http://www.avrx.se/
* [http://www.wedis-basteleck.de/ Wedis-Basteleck] - Modellbahn DCC-Servo-Zubehördecoder DCC Servo Decoder mit ATmega8 / Servo Differenzierbaugruppe für Modellbau
* http://web.archive.org/web/20050415222337/http://www.hebel23.de/ RDS RADIO: ATMega32, TEA5757, T6963C, TDA7330B in C
* [http://www.gasenzer.dk Analog/Digital and MPU Eletronic Projects] PAL/VGA Terminal, CallerID, Ethernet, Wireless Bridge, LPC2214, AT91RM9200, Sony Unilink Controlled Wireless MP3 Player.
* [http://www.circuitcellar.com/avr2004/ Circuit Cellar AVR Design Contest 2004] mit Projektbeschreibungen
* [http://www.circuitcellar.com/avr2006/ Circuit Cellar AVR Design Contest 2006] mit Projektbeschreibungen
* [http://www.heesch.net/microcontroller.aspx/ Homepage von Stefan Heesch] - AVR Mikrokontroller Projekte, z.B. WLAN und AVR, netzwerkgesteuertes RGB Licht, IDE-Interface, DS1821 Thermometer, Morse-Dekoder u.a.
* [http://www.schaltungsforum.de Das Schaltungsforum] ist eine Seite für Anfänger und Profis welche ständig mit Tutorials erweitert wird. Stellt Eure Projekte online. Die Seite befindet noch im Aufbau und Eure Mithilfe ist erwünscht.
* [http://avrprojekte.de/] Viele Projekte mit LEDs(LED-Matrixen) und AVRs
* [http://arduino.milkcrate.com.au/ little-scale's arduino page]
* [http://www.sebastianweidmann.de www.sebastianweidmann.de] Grundlagen zum Thema Platinen ätzen, Bohren, Durchkontaktierungen und Projekte Tipps/Tricks mit Atmel AVR Microcontrollern
*[http://www.jtronics.de/elektronik-avr.html Junghans Electronic Page] u.a Nokia 3310 LCD Ansteuerung in "C"(aktualisiert 2010), TWI/USI, Quadcopter
* [http://www.familie-finke.com/ http://www.familie-finke.com/] Die Website von Thomas Finke mit diversen Elektronikprojekten, wie z.B. STK-LAN (AVR im Netzwerk mit HTTPD, SNMP,...), UV-LED-Belichter, HPGL-Plotter.
* [http://phil-zone.de/ Philips Projektsammlung] Elektronik Projekte (µC,CMOS,Analog,...), Tutorials und nützliche Online-Tools
* [http://www.iuac.res.in/~elab/phoenix/index.html Phoenix] allows you to develop science experiments by connecting sensor / control elements to a computer and access them through software. The project was started by Inter University Accelerator Centre, with the objective of improving the laboratory facilities at Indian Universities, and growing with the support of the user community. Phoenix depends heavily on Python language. The data acquisition, analysis and writing simulation programs to teach science and computation. The hardware design is freely available. The project is based on Free Software tools and the code is distributed under GNU GPL. (Atmega16)
* [http://code.google.com/p/usb-pwm-generator/ USB PWM Generator] Low Cost PWM Generator, über USB Programmierbar. 1Hz - 120khz Duty Cycle 1 - 99 %.

==== Schnittstellen ====
===== TCP/IP =====
* Kostengünstige und schnelle WLAN Anbindung an Mikrocontroller mit Wiz610wi. Bezugsquelle inkl. praktischer Adapterplatine bei: [http://www.shop.display3000.com/elektronikmodule/ethernet-wlan/index.html Display3000]
* [http://www.laskater.com/projects/uipAVR.htm TCP/IP Stack für AVR] mit Realtek RTL8019AS oder Axis AX88796 Netzwerk-Chips (open source für avr-gcc und Imagecraft). Passende Hardware in [http://www.edtp.com/ diesem online-shop]
* [http://www.ethernut.de Ethernut] - AVR based Hardware with Ethernet-Interface, Multithreading OS, Software and Hardwaredesign is free
* [http://www.embedded-it.de/microcontroller/eNet-sam7X.php eNet-sam7X] Embedded Ethernet Modul im DIL64 Format mit kompletten OpenSource Board Support Packake auf Ethernut / Nut/OS Basis. Industrie geeignet
* [http://www.ethersex.de/index.php/Feature_Liste Ethersex] - Trotz des bescheuerten Namens sehr empfehlenswert. Viele flexibel einbindbare Module für diverse Hardware.
* [http://wiki.neo-guerillaz.de OpenMCP] Bekanntes Board auf Basis des ATmega2561 und ENC28j60. Läuft auch auf dem AVR-NETIO und dem myAVR.
* [http://www.cesko.host.sk/IgorPlugUDP/IgorPlug-UDP%20(AVR)_eng.htm IgorPlug-UDP AVR] - Ethernet & UDP/IP in Software implementiert
* [http://members.home.nl/bzijlstra/software/examples/RTL8019as.htm] RTL8019 Bascom
* [http://members.home.nl/bzijlstra/software/examples/RTL8019as.htm AVR und RTL8019]
* [http://avr.auctionant.de/avr-ip-webcam AVR IP Webcam]
* http://mikrocontroller.cco-ev.de/de/webcam.php
* [http://avr.auctionant.de/avrETH1/ avrETH1 - Webserver mit enc28j60 und Webcam-Support]
* [http://www.sics.se/~adam/uip/ uIP-Stack, Teil des Contiki OS]
* [http://www.sics.se/~adam/lwip/ LwIP-Stack]
* [http://www.harbaum.org/till/spi2cf/ WLAN-Implementierung auf Basis einer PRISM-CF-Karte und uIP]
* http://www.circuitcellar.com/AVR2006/winners/DE/AT2581.htm MEGA128(CAN) PCMCIA
* [http://www.ic-board.de/index.php?cat=c2_ICnova-Module.html AVR32 AP7000 Linux Board] mit 2xEthernet, TFT, Audio, SDCARD, USB-Host/Devive, Funk...
* [https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet AVR-Board mit Ethernet mit dem ENC28J60 von Microchip]
* [http://www.roland-riegel.de/mega-eth/ AVR-Ethernet-Board mit extra SRAM, SD/MMC, USB und zugehöriger Software]

===== CAN =====
* [http://www.canathome.de/ Can@Home] - CAN als "Installationsbus", u.a. mit AVRs (D)
* [http://www.iuse.org/ www.iuse.org] - Hausautomatisierung auf CAN Basis
* [http://www.port.de/ www.port.de] - Professionelle CAN/CANopen Entwicklungswerkzeuge
* [http://can-wiki.info CAN-WIKI] - spezielle Wiki Site für CAN bus (Englisch)
* [[CAN-Bus]] - Eintrag in diesem Wiki
* [[CAN als Hausbus]] - Eintrag in diesem Wiki
* [http://www.canhack.de/ www.canhack.de] - Ein Forum, dass sich mit dem CAN bus im Auto beschäftigt
* [http://www.edevices.lt/ www.edevices.lt ] - USB2CAN inexpensive USB to CAN bus converter

===== USB =====
* [http://www.embedded-it.de/microcontroller/microcontroller-module.php eUSB-162 und eUSB-LCD] - At90USB162 basiertes universelles USB Prototypen / Mikrocontroller Modul und USB Terminal Interface für HD44780 kompatible LCDs auf Basis der Lufa Library
* [http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20(AVR)_eng.htm Igor-Plug] - USB Device interface in AVR Firmware - no extra Interface IC needed, read the License
* [http://www.obdev.at/products/vusb/index-de.html V-USB] – USB-Implementation in C nach gleichem Prinzip wie Igor-Plug, aber einfacher zu verwenden, GPL-ähnliche Lizenz (Nutzung des Projekts ''erfordert'' Veröffentlichung), englisch kommentierter Code
* [http://www.xs4all.nl/~dicks/avr/usbtiny/ USBTiny] – weitere Software-USB-Implementierung in C; sehr ähnlich AVR-USB; steht aber unter GPL; relativ wenige Beispiele
* MJoy USB Joystick Controller on AVR ATmega8
* [http://www.ime.jku.at/tusb/ TUSB3210-Controller, HID, LIBUSB] Ein Projektseminar, in dem es darum ging, die USB-Schnittstelle des TUSB3210 zu aktivieren und die Daten eines ADC an den PC zu senden. USB-Implementierung für µC und PC.
* [http://www.b-redemann.de Steuern und Messen mit USB - FT232, 245 und 2232] Das aktuelle Buch zu den USB-Controllern von FTDI. Viele Beispielprogramme in C, zwei Projektbeschreibungen: I²C-Bus mit LM75A und ein Web-Projekt. Bauteilesatz und USB-Modul mit dem FT2232 zum schnellen Einstieg in die Thematik. Buch / Teilesatz über Segor oder dieser Seite erhältlich.
* [http://www.eltima.com/products/usb-over-ethernet/ USB to Ethernet Connector] - Share your USB devices via LAN/Internet
* [http://www.ixbat.de Viele kleine USB Projekte] Rund um die Bibliothek usbn2mc http://usbn2mc.berlios.de. Dies ist eine einfache Bibliothek für den USBN9604/03 von National Semiconductor
* [http://www.rahand.eu Mega8D12] - Schritt für Schritt zum virtuellen COM-Port. Ein Einsteiger-Tutorial zur CDC-Klasse mit Schaltung und Firmware (ATmega8 und PDIUSBD12).
* http://www.maares.de/tools USB_ISO: Isolierter Schnittstellenwandler USB auf RS232 (TTL) mit FT232RL und ADUM1402. Galvanische Trennung für das Zielsystem.
* [http://www.embedded24.net USB HID Host Treiber] - USB HID Treiber DLL für Windows (Demo Projekte für Visual Studio 2010 C++, C# und VB).

===== DMX512 =====
* [http://Dworkin-DMX.de Konverter RS232 zum DMX512] Steuerung DMX-fähigen Geräten mit einem PC. Es gibt Low cost Variante zum selber basteln.
* [http://www.hoelscher-hi.de/hendrik/light/profile.htm Hennes Sites] Bauanleitungen für DMX-Dimmerpacks, DMX-Switchpacks, PWM-Controller, ... Tutorial für Senden und Empfangen von DMX-Daten mit AVRs.
* [http://www.lj-skinny-development.de/lj2000/ DMX Lichtanlage im Selbstbau] Projekt für den Selbstbau einer kompletten Lichtanlage zur Steuerung über DMX. Projekt beinhaltet alles was man für den Betrieb einer eigenen Lichtanlage benötigt (Mischpult, Steuersoftware, Dimmer, Scanner mit Iris, Shutter-Dimmer, 2 rotierenden Goborädern, 2 Farbrädern, CMY-Farbmischeinheit, Prisma, Fokus ...).
* [http://digital-enlightenment.de Digital Enlightenment ]Verschiedene DMX-Selbstbauprojekte

===== PS2 =====
* [http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_id=1086&item_type=project&timestamp=2007-09-04%2018:34:41 PC keyboard to an AVR]

===== LANC =====
* [http://dsc.ijs.si/3dlancmaster/ 3D LANC Master from Damir Vrancic] is a device which keeps in synchronisation some of Sony camcorders by using LANC (CONTROL-L, ACC) protocol. (Open Hardware + Open Source, Atmega8).
* [http://jochendony.homeip.net/content/view/22/26/ LANC Lib] for AVRGCC. Read and write LANC commands.
* [http://blog.makezine.com/archive/2008/12/controlling_sony_camcorders_with_th.html Controlling Sony camcorders with the Arduino]

===== MMC/SD-Card =====
* [http://www.roland-riegel.de/sd-reader/index.html MMC/SD card reader example application] von Roland Riegel (Atmega8, Atmega168 für FAT16)
* [http://www.captain.at/electronic-atmega-mmc.php MMC Flash] bzw. [http://www.captain.at/electronic-atmega-sd-card.php SD Flash ] Memory Extension für Atmegas von Captain. (Atmega16, Atmega32)
* http://arm.hsz-t.ch MMC, SD, SDHC Kartentreiber für ARM7 Mikrocontroller
* [http://www.mikrocontroller.net/articles/FAT32 Wiki und FAT16/32 Bibliothek für atmega]

==== LC-Displays ====

===== Text (character-mode) HD44870 =====
* [http://jump.to/fleury P.Fleury]
* avrfreaks Projekt 59 (Chris E.) und andere
* Procyon avrlib v. Pascal Slang (GPL)
* Bray
* [http://www.sprut.de/electronic/lcd/index.htm Spruts LCD-Seite]
* [http://elm-chan.org/docs/lcd/lcd3v.html Standard-LCD auf 3V betreiben (eng)]
* [http://www.harbaum.org/till/lcd2usb LCD2USB, LCD mit AVR am USB betreiben]
* [http://www.simon-brenner.ch/projekte/lcd-display 4x40 LCD Projekt, Microchip]

===== Grafik T6963C etc. =====

* http://www.holger-klabunde.de/avr/avrboard.htm#t6963
* [[Projekt T6963-LCD-Ansteuerung]] nur PC, keine Änderung seit Juli 2006
* avrfreaks.net - TOSHIBA_LCD_T6963C, AVR Graphics
* http://www.mikrocontroller.net/topic/48456 C
* http://www.mikrocontroller.net/topic/54563 C
* http://www.mikrocontroller.net/topic/48584 ASM
* [http://passworld.co.jp/ForumMSP430/viewtopic.php?t=47 Grafik LCDs] - 128 x 112 Grayscale für MSP430 und andere uCs.
* http://www.display3000.com/ Farb-TFT-Module inkl. Mikrocontroller (ATMega128; ATMega2561 und AT90CAN128)
* [http://www.tklinux.de/sed1330.html SED1330 an ATMega]. Library für SED 1330 controller an ATmega
In der Codesammlung gibt es auch für andere Controller was.

===== Siemens S55/C60 =====
* [http://www.module.ro/siemens_lcd.html S55-Display Pinbelegung]
* [http://www.mikrocontroller.net/topic/22643 Forumbeitrag]

===== Siemens S65/M65/CX65 =====
* [http://www.superkranz.de/christian/S65_Display/DisplayIndex.html S65-Display] vom Siemens S65/M65/CX65, 132x176 Pixel, 65536 Farben, günstig als Ersatzteil zu bekommen.

===== Nokia 3210/3310 =====
* [http://www.jtronics.de/elektronik-avr/lcd-display-nokia3310 Bibliothek für Nokia 3310 Lcd Ansteuerung in "C" von http://www.jtronics.de - sehr gut (aktualisiert 2010)]
* [http://www.microsyl.com MicroSyl.Com]

* [http://www.deramon.de/nokia3310lcd.php Deramon.de]


===== Nokia 6100 LCD =====

* [http://www.myplace.nu/mp3/download/download.php Yampp 7 Software Download Seite]: Archiv "yampp-7 with colour LCD firmware" enthält avr-gcc/avr-as Routinen für 6100-LCDs mit Philips- oder Epson-Controller (nicht direkt eine "Library")
*[http://www.e-dsp.com/controlling-a-color-graphic-lcd-epson-s1d15g10-controller-with-an-atmel-avr-atmega32l/ S1D15G10]: Routine code für den Epson S1D15G10 Controller
*[http://thomaspfeifer.net/nokia_6100_display.htm Nokia 6100 Display am AVR] Anzeige von RGB-Bildern (für avr-gcc)
*[http://www.optixx.org/ www.optixx.org] Code zur Ansteuerung von Philips und Epson
*[http://www.zipfelmaus.com/nokia6100lcd_en/ http://www.zipfelmaus.com/nokia6100lcd_en/] --> unter Download: Tool zum Konvertieren von BMPs in h-Files zum Ausgeben auf dem Display

===== KS0108 =====
* [http://hubbard.engr.scu.edu/embedded/avr/avrlib Procyon avrlib (GPL)]
* avrfreaks UP
* apetech.de nicht mehr erreichbar http://www.mikrocontroller.net/topic/68316

====GPS====
* http://www.holger-klabunde.de/avr/avrboard.htm#GPSdisplay GPS-Daten auf LCD
* [http://www.geoclub.de/forum57.html www.geoclub.de] - Elektronik beim Geocaching
* [http://passworld.co.jp/ForumMSP430/viewtopic.php?t=22 passworld.co.jp] - Do It Yourself GPS

== [[8051|8051 / MCS51]] ==
* [http://mcu8051ide.sourceforge.net/ MCU 8051 IDE] - MCU 8051 IDE is a new modern graphical IDE for microcontrollers based on 8051. MCU 8051 IDE is noncommercial open-source software for Linux.
* [http://www.rakers.de/catalog Dr. Rakers] Entwicklungssystem mit C-Compiler, BASIC-Compiler und Makroassembler für alle 8051-Mikrocontroller (80C552, 80C515(C), 80C537). Auch für Hobbyisten bezahlbar.
* [http://www.progshop.com/versand/software/prog-studio/index.html Prog-Studio] - Moderne Assembler Entwicklungsumgebung für 8051 Mikrocontroller mit Debugger, Edit & Continue, Code-Folding, Intelli-Sense, Monitorung und mehr
* [http://www.yCModule.de yCModule: µController-Systeme] - Preisgünstige µController-Module, ISP-Programmiertools und Applikationsboards
* [http://www.erikbuchmann.de/ Erik Buchmanns Mikrocontroller-Seite] - Assemblerkurs und mehrere Projekte
* [http://www.holger-klabunde.de/projects/8051.htm Experimentierboard für 8051 Controller] von Holger Klabunde.
* [http://www.woe.de.vu/ World Of Electronics] - Projekte mit den 8051-Controllern von Atmel
* [http://www.thomas-wedemeyer.de/elektronik/8051/8051.html Controllerplatine mit SAB80C535]
* [http://www.maxim.ph.tc Selbstbau-Programmer] für 2051er
* [http://www.nomad.ee/micros/8052bas.html 8052 BASIC Projects] - IDE-Interface
* [http://home.t-online.de/home/s.holst/sh51/index.html Mikrokontroller sh51] Schaltplan für 80C535-Board
* 8051-Makroassembler [http://plit.de/asem-51/ ASEM-51] (Freeware)
* [http://sdcc.sourceforge.net/ SDCC - Small Device C Compiler] - freier ANSI-C compiler für Intel 8051, Maxim DS80C390 und Zilog Z80 kompatible Controller.
* [http://sdccokr.dl9sec.de/ The SDCC Open Knowledge Resource]
* [http://www.wickenhaeuser.de/ Wickenhäuser C Compiler] - Preisgünstiger C Compiler
* [http://home.tiscali.cz:8080/~cz056018/lanc_a.htm LANC-Remote] Projekt von Jiří Šmach zur Steuerung von Videorekordern oder Camcordern über das Control-L (LANC) Protokoll mit Hilfe eines AT89C2051.
* [http://www.microcontroller-starterkits.de Microcontroller-Starterkits] Starter-Kits für verschiedene Microcontroller (D) preisgünstige Platinen (ab 12,95 Euro für AT89S8252). Beim uC-Dualboard : Das Board ist nutzbar mit AVR-Controllern und 8051-Controllern!
* [http://turbo51.com Turbo51 - Free Pascal compiler for 8051]
* [http://self8051.de/ self8051.de] - Dein Nachschlagewerk - Befehlsreferenz, Eigenschaften, Derivate
* [http://cmon51.sourceforge.net/ CMON51] - freier Onboard Monitor und Debugger, anpassbar an unterschiedliche 8051 kompatible Mikrocontroller
* [http://et-tutorials.de/632/kostenloser-mikrocontroller-kurs/ Mikrocontroller Video Tutorial] Video-Tutorial für Einsteiger (C-Kurs + Einführung 8051)

== MSP430 ==
* [http://www.mikekohn.net/micro/naken430asm_msp430_assembler.php naken430msp] - MSP430 Assembler von Michael Kohn (GPL)
* [http://www.mathar.com MSP430 Tutorials] - Tutorials, Anleitungen und viele Beispielprojekte mit dem MSP430-Mikrocontroller
* [http://www.student-zw.fh-kl.de/~stwi0001/imp/msp430/pwm430/index.htm Pulsweitenmodulation mit dem MSP430] - sehr ausführliche Einführung
* [http://www.thomas-wedemeyer.de/elektronik/msp430/msp430.html Kleine Projekte mit dem MSP430] - Schaltplan und Layout zu einem MSP430F149-Board und einem ADXL-G-Sensor mit MSP430
* [http://tinymicros.com/embedded/MSP430/ The MSP430 Bugspray Database] - umfangreiche Datenbank für Bugs in MSP430-Controllern
* [http://msp430.info MSP430.info] - Portalseite für MSP430; Info, Projekte (MIDI, USB)
* [http://groups.yahoo.com/group/msp430 Yahoo group MSP430] - lebhaftes Forum mit vielen MSP430-Experten
* [http://homepage.hispeed.ch/py430/mspgcc/ mps430-gdb und Eclipse] - Eine Anleitung von Chris Liechti
* [http://passworld.co.jp/ForumMSP430 Forum MSP430] - Projekte mit MSP430 (GPS, BlueTooth usw...)
* TI Design-Wettbewerb: http://www.designmsp430.com/View.aspx (Dateien liegen evtl. in /projects/) [2011-01-24: redirect zum TI Wiki, Projekte nicht mehr vorhanden]
* [http://www.sics.se/project/mspsim MSPsim] - a Java-based simulator of MSP430 sensor network platforms (BSD License (revised))
* [http://develissimo.net/de/msp430entwicklung MSPGCC + Eclipse + msp430-gdbproxy / Linux / Debian / Ubuntu] - Anleitung / Tutorial zur Installation der MSPGCC Toolchain + Eclipse + msp430-gdbproxy für Linux / Debian / Ubuntu Lang=Deutsch und Englisch
* [http://travisgoodspeed.blogspot.com/ Travis Goodspeed's Blog] - Home of the [http://goodfet.sourceforge.net/ GoodFET] Programmer
* [http://www.43oh.com/ Four-Three-Oh!]

=== MSP430 Launchpad ===
* [http://processors.wiki.ti.com/index.php/MSP430_LaunchPad_(MSP-EXP430G2)?DCMP=launchpad&HQS=Other+OT+launchpadwiki MSP430 LaunchPad Wiki] bei TI
* [http://hackaday.com/2010/08/11/how-to-launchpad-programming-with-linux/ How-to: Launchpad programming with Linux] auf hackaday.com
* [http://springuin.nl/en/articles/launchpadwindows TI Launchpad programming and debugging with Open Source tools on Windows] (Eclipse, MSPGCC4, Insight, msp430-gdbproxy)
* [http://osx-launchpad.blogspot.com/ MSP430 LaunchPad toolchain for Mac OS X]

=== EZ430 Chronos ===
* [http://processors.wiki.ti.com/index.php/EZ430-Chronos?DCMP=Chronos&HQS=Other+OT+chronoswiki EZ Chronos Wiki] bei TI

== ARM ==

=== Herstellerseiten ===
* [http://www.arm.com ARM] - Entwickler des ARM-Prozessorkerns (kein Hersteller von ICs)
* [http://infocenter.arm.com ARM Infocenter] Sammlung Technischer Informationen

* [http://www.analog.com/ Analog Devices] ADuC7xxx ARM7TDMI Serie unter ''Analog Microcontrollers''
* [http://www.atmel.com/products/AT91/ Atmel AT91 Startseite]
* [http://www.at91.com AT91.COM] - Atmel ARM Informationsseite (Forum, Beispielcodes etc.)
* [http://www.cirrus.com/en/products/pro/techs/T7.html Cirrus Logic]
* [http://www.energymicro.com/ Energy Micro] EFM32 mit Cortex M3 Kern
* [http://www.freescale.com/mac7100 Freescale MAC7100]
* [http://www.hilscher.com Hilscher netX] (ARM926 core)
* [http://www.intel.com/design/intelxscale/ Intel XSCALE Startseite], siehe auch [http://www.marvell.com/ Marvell]
* [http://www.luminarymicro.com/ Luminiary Micro (TI)] Controller mit Cortex M3 core
* [http://www.standardics.nxp.com/microcontrollers/ NXP (ehemals Philips) Microcontroller Startseite] für sämtliche Mikrocontroller (ARM7, ARM9, Cortex-M0, -M3, MCS51 etc.), neben LPC2000, LPC3000 auch die LH7xxxx BlueStreak-Serie (ehemals Sharp Microelectronics)
* [http://www.lpc2000.com lpc2000.com] Infoseite für NXP (ex. Philips) LPC1700 Cortex-M3 basierende Typen, LPC2000, ARM7 basierende Typen und LPC3000, ARM9 basierende Typen. Auch andere Cortex-M3 Bausteine sind erfasst
* [http://www.okisemi.com/eu/1.Products/ARM32bit.html OKI ARM-Controller Startseite]
* [http://www.samsung.com/Products/Semiconductor/ Samsung] ARM7/9 unter ''Mobile SoC''
* [http://mcu.st.com/mcu/ STMicroelectronics (ST) Microcontroller Startseite] u.a. STR7, STR9, STM32 Support-Forum
* [http://www.ti.com/ Texas Instruments] TMS470 ARM7TDMI Serie
* [http://www.toshiba.com/taec/ Toshiba] Controller mit ARM9 und Cortex-M3 core

=== Information (Foren, Mailinglisten, Linksammlungen) ===
* [http://www.neko.ne.jp/~freewing/cpu/arm_olimex/ Freewing Linksammlung] zu den NXP (ex. Philips) LPC-ARM7-Controllern (Assemblerbeispiele u.a. für Nokia 3310-GLCD)
* [http://www.open-research.org.uk/ARMuC ARM Microcontroller Wiki]
* [http://arm.hsz-t.ch arm.hsz-t.ch] Einfühung in ARM7 Mikrocontroller und uClinux.
* [http://tech.groups.yahoo.com/group/ADuC7000/ ADuC7000 Yahoo-Group]
* [http://www.at91.com AT91 Forum] (Atmel Rousset)
* [http://tech.groups.yahoo.com/group/AT91SAM/ AT91SAM Yahoo-Group]
* [http://en.mikrocontroller.net/forum/17 arm-elf-gcc WinARM Forum] (auch für Yagarto)
* [http://www.codesourcery.com/archives/arm-gnu/maillist.html Sourcery G++ Lite Edition User Forum/Mailing-List]
* [http://tech.groups.yahoo.com/group/gnuarm/ GNUARM Yahoo-Group]
* [http://www.keil.com/forum/ Keil/ARM Forum]
* [http://groups.yahoo.com/group/lpc2000/ LPC2000 Yahoo-Group]
* [http://www.mcu-related.com MCU related] Neuigkeiten zu MCUs, überwiegend ARM / Cortex-M3 basierend mit Vergleichen von RTOS und anderen Entwicklungstools
* [http://forum.sparkfun.com/ Sparkfun Foren]
* [http://mcu.st.com/mcu/modules.php?name=Splatt_Forums STMicroelectronis Forum]
* [http://www.stm32circle.com/ Forum for STM32 moderated by Raisonance] Sehr viele Beispielprogramme in Source fuer STM32 und den Primer2 von Raisonance

=== Entwicklungswerkzeuge (Compiler/Assembler/Debugger/Tools) ===

* [http://www.st-angliamicro.com/software.asp Anglia Idealist IDE und Anglia Toolchain] GNU toolchain für Win32-hosts inkl. Beispielen für STR7, STR9 und STM32. IDE kostenlos aber registrierungspflichtig
* [http://atollic.com/ attolic] TrueSTUDIO
* [http://www.codesourcery.com/gnu_toolchains/ Codesourcery] GNU Toolchains für ARM (Hosts: Linux, MS Windows, Solaris; Targets: "bare-metal", arm-linux, SybianOS)
* [http://devkitpro.org/ devkitPro/devkitARM] GNU-Toolchain für MS-Windows "Hosts". Vor allem auf GBA abgestimmt aber auch für andere ARM-Controller geeignet
* [http://www.ghs.com/ Green Hills Software]
* [http://www.hitex.de Hitex] IDE für diverse Compiler, Debugger
* [http://www.iar.com IAR] Embedded Workbench, kommerzielle IDE/Compiler, codegrößenbeschränkte Evaluierungsversion verfügbar
* [http://www.isystem.com/ iSYSTEM] Integrated Development Environment, USB/JTAG interface, OnChip Emulation and Trace
* [http://www.keil.com Keil/ARM MDK-ARM] kommerzielle IDE/Compiler, unterstützt zwei Compiler (ARM RealView, GNU/gcc), codegrößenbeschränkte Evaluierungsversion verfügbar (IDE/Compiler unbeschränkt für GNU), guter Debugger, sehr guter Simulator, Simulator und Debugger in der Evaluierungsversion auch bei Nutzung der GNU-Toolchain mit Größenbeschränkung
* [http://mct.de/download.html#free MCT Demoversion C-Compiler für ARM und 68k] ARM C-Compiler basiert auf GCC laut Herstellerinformation jedoch mit Codegrößenbeschränkung 
* [http://www.mpeforth.com www.mpeforth.com] - A free Forth system with 125 page manual for all Philips LPC2xxx CPUs with at least 64k Flash and 16k RAM and cystal frequency of 10, 12, or 14.7456 MHz.
* [http://www.raisonance.com/ Raisonance] Ride, RKit-ARM
* [http://www.rowley.co.uk/ Rowley] Kommerzielle IDE für GNU-Compiler, eigene libc (nicht newlib), Debugger (inkl. gutem Support für Wiggler)
* [http://h-storm.tantos.homedns.org/gcc_arm.htm Tantos gcc for ARM Targets] eine weitere ARM-GNU-Toolchain für MS-Windows "Hosts"
* [http://www.yagarto.de Yagarto] GNU arm-eabi-Toolchain, Eclipse, OpenOCD für Win32 inkl. Setup
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/index.html#winarm WinARM] eine an WinAVR angelehnte Sammlung von Entwicklungswerkzeugen (binutils, arm-elf-gcc, newlib, ''newlib-lpc'', Programmers Notepad, ''Beispiel-Makefiles und Beispielcode'') für alle ARM-Controller. Beispiele für Philips LPC2000 und Atmel AT91SAM7S (ARM7TDMI) u.a.
* [http://rtlab.tekproj.bth.se/wiki/index.php/Dissy#Architecture_support Dissy] is a disassembler for Linux and UNIX which supports multiple architectures and allows easy navigation through the code. Dissy is implemented in Python and uses objdump for disassembling files.
* [http://www.sinelabore.com sinelaboreRT] - generiert leicht lesbaren C-Code aus einer Zustandsmaschine. Die Generierung berücksichtig speziell die Bedürfnisse eingebetteter Echtzeitsysteme.
* http://arm.hsz-t.ch Entwicklungsumgebung für ARM7 Mikrocontroller basierend auf der Knoppix CD. Keine Harddisk installation nötig für uClinux.

* [http://openocd.berlios.de/web/ OpenOCD] Open On-Chip Debugger: Schnittstelle ("gdb-Server") zwischen verschiedenen JTAG-Interfaces (u.a. auf FTDI2232-Basis, "Wiggler"-ParPort und andere) und GNU-debugger (gdb/Insight-gdb) Flash-Programmierfunktion für LPC2k, AT91SAM7S, LM3S, STM32 und viele andere interne und externe Flashspeicher (Open Source, GPL, unter anderem auf MS Windows und Linux lauffähig)
* [http://macraigor.com/full_gnu.htm OCDLibRemote] Schnittstelle zwischen WIGGLER-kompatibler JTAG Hardware und dem GNU-Debugger (gdb)
* [http://gdb-jtag-arm.sourceforge.net/ GDB-JTAG-ARM] GDB JTAG Tools
* [http://jtagpack.sourceforge.net/ JTAG-Pack] GDB JTAG Tools
* [http://www.hjtag.com H-JTAG] RDI-Interface für Wiggler, Flash-Funktionen für diverse interne und externe Speicher
* [http://www.clibb.de/ lpc21isp] Flashutility für LPC21xx, ISP via "Bootloader" ("multiplattform")

*[http://www.abatron.ch Abatron] BDI1000 & BDI2000, On-Chip Debuggers für ARM, 68k, Coldfire uvm.
* [http://www.amontec.com Amontec] JTAGkey, JTAGkey2(P): JTAG-Adapter auf Basis des FTDI2232(H)
* [http://www.hjtag.com/product_intro.html H-JTAG USB Emulator]
* [http://www.keil.com Keil/ARM ULINK/ULINK2/ULINK-ME] JTAG-Adapter, USB-Anschluss, wird von Keil uVision unterstützt, ULINK2 teilw. auch von Codesourcery G++ (lt. Hestellerangaben)
* [http://www.kristech.eu Kristech] USB-Scarab, JTAG Adapter, kommt mit eigener Debugger-UI, kompatibel zu Olimex
* [http://www.lauterbach.de Lauterbach] TRACE32 JTAG-Adapter, USB und Ethernet-Anschluss, eigene Software
* [http://www.olimex.com Olimex] JTAG-Adapter: Wiggler-Nachbau (ParPort) und Adapter auf Basis des FTDI2232 (USB)
* [http://www.ronetix.at/peedi.html Ronetix Peedi]
* [http://www.segger.de Segger J-Link] JTAG-Adapter, USB-Anschluss, unterstützt z. B. von IAR, Keil uVision (via RDI) (OEM: IAR J-Link, SAM-ICE)
* [http://www.signalyzer.com/ Signalyzer] Signalyzer Tool, u.a. JTAG-Adapter auf Basis des FTDI2232
* [http://www.simonqian.com/en/Versaloon/index.html Simon Qians Versaloon]

=== Tutorials und Beispiele ===
* [http://www.dreamislife.com/arm/ LPC210x ARM7 Microcontroller Tutorial] - Assembler-Beispiele (arm-elf-as) für das Olimex LPC-MT-Board (Philips LPC2106 ARM7TDMI)
* [http://re-eject.gbadev.org/index.php gcc-Assembler für ARM] - Befehlsübersicht
* [http://patater.com/gbaguy/gbaasm.htm GBA ASM Tutorial] - ARM7 Assembler Tutorial mit arm-elf-as ("gcc") (Allgemein und GBA)
* [http://www.robsite.de/daten/tutorials/devgba/gba_asm1.html GBA Assembler Tutorial] - ARM7TDMI, Schwerpunkt auf GBA
* [http://www.sparkfun.com/tutorial/ARM/ARM_Cross_Development_with_Eclipse.pdf Eclipse+CDT+gnuarm-Tutorial]
* [http://mct.de/download/armsamples/map.html Beispiele in C, für ARM7-Controller von Philips und ADI]
* [http://www.embedded.com/design/opensource/201802580 Embedded.com: Building Bare-Metal ARM Systems with GNU] Teil 10, Links zu den Teilen 1-9 auf der Seite
* [http://www.sparkfun.com/datasheets/DevTools/SAM7/at91sam7%20serial%20communications.pdf AT91SAM7 Serial Communications] von James P. Lynch (PDF, www.sparkfun.com)
* [http://www.kaczurba.pl/aduc ADuC7000 Tutorial] von Witold Kaczurba (www.kaczurba.pl)

=== Projekte und Quellcodebibliotheken ===
* [http://hubbard.engr.scu.edu/embedded/arm/armlib/ Procyon ARMlib-LPC2100] - Treiber, Beispiele (Lizenz: GPL, kaum weiterentwickelt)
* [http://www.standardics.nxp.com/support/documents/?type=software NXP BlueStreak] Code für LH7xxxx (ehemals Sharp)
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/index.html M. Thomas' ARM Projekte] "Projectvorlagen" für AT91SAM7 und LPC2000 mit GNU-Toolchain Einsteiger-Projekte für AT91SAM7, LPC2000, ADuC7000 u.a. (u.a. Blinky, UART, Interrupt, C++, GLCD mit KS0108, DS18x20, DCF77, Anpassungen von FAT16/32-Libraries) 
* [http://mcu.st.com/ STMicro] Treiber und Beispiel für STR7, STR9 und STM32
* [http://wiki.sikken.nl/index.php?title=LPCUSB LPCUSB] - Open-source [[USB]] stack for the built-in USB controller in LPC214x microcontrollers von Bertrik Sikken. [http://lpcusb.cvs.sourceforge.net/lpcusb/host/benchmark/main.c?revision=1.2&view=markup Sample code]
* [http://www.olimex.com Olimex] Einige Beispiele auf den "Produktseiten" der ARM Boards.
* [[ARM MP3/AAC Player]]
* [http://www.jcwren.com/arm/ J.C. Wrens Beispielprojekt] für LPC214x
* [http://www.keil.com/download/list/arm.htm Beispiele von Keil] abgestimmt auf deren Boards und Realview-Toolchain, Portierung auf andere Boards und Compiler relativ einfach, Lizenz beachten.
* [http://www.luminarymicro.com/ Luminary Micro Driverlib] für Stellaris Cortex-M3
* [http://r2d2.stefanm.com/gps-tracker.html GPS-Tracker] mit Navigation auf LPC2103-Basis (Complier: GCC)
* [http://elua.berlios.de elua] Lua für ARM-controller
* [http://freemodbus.berlios.de/ FreeMODBUS] "A Modbus ASCII/RTU and TCP implementation" (für STR71x, AT91SAM7, LPC214x, auch: AVR, MSP430 u.a.)
* [http://bettyhacks.com BettyHacks] Freie Firmware für die "interaktive TV-Fernbedienung" betty-tv (ARM7tdmi, 2MB Flash, 160 x 128 Pixel 2 bit LCD, CC1100, IR, Lautsprecher,..)

=== Betriebssysteme ===
* [http://agnix.sourceforge.net/ Agnix]
* [http://www.bertos.org/ BeRTOS] is a completely free, open source, real time operating system (RTOS) suitable for embedded platforms. Runs on many microprocessors and microcontrollers, ranging from 8 bits to 32 bits CPUs and even PCs.
* [http://chibios.sourceforge.net/ ChibiOS/RT]
* [http://www.stm32circle.com/resources/upgrade.php Circle-OS for STM32] Kostenloses OS, sehr klein mit Basisfunktionen fuer STM32
* [http://coocox.org/ CoOS]
* [http://sources.redhat.com/ecos/ eCos] - "Real-Time-Operating-System" o.a. auch für ARM7
* [http://www.freertos.org/ FreeRTOS (.org!)] - "Real-Time-Kernel" unter anderem für ARM7 (LPC2xxx) auch AVR, MSP430, '51er
* [http://sourceforge.net/projects/funkos/ FunkOS]
* [http://l4ka.org/ L4Ka]
* [http://www.toradex.com/colibri_downloads/Linux/readme.txt Linux 2.4.29 für Toradex Colibri] basierend auf Intel XScale PXA270
* [http://www.linux4sam.org Linux4SAM] Informationen, Anleitungen und Code zur Anwendung von Linux auf AT91SAM9xxx
* [http://www.freertos.com/ NicheTask] (URL ist www.freertos.com aber hat nichts mit FreeRTOS(.org) zu tun)
* [http://www.ethernut.de/en/software/index.html Nut/OS] Echtzeitbetriebssystem für Mikrocontroller (ARM, AVR, AVR32, Cortex M3 u.A). Multitasking und vollständiger TCP/IP Stack inklusive. Leicht zu erlernen und viele Beispiele
* [http://nuttx.sourceforge.net/ NuttX RTOS] (ARM7TDMI port for TI TMS320C5471 also called a C5471 or TMS320DM180).
* [http://www.phoenix-rtos.org/ Phoenix-RTOS]
* [http://picoos.sourceforge.net/ PicoOS]
* [http://prex.sourceforge.net Prex] is a portable real-time operating system for embedded systems. The small, reliable, and low power kernel is written in the C language based on microkernel design. The file system, Unix process, and networking features are provided by user mode tasks. (ARM, i386, geplant: MIPS, PowerPC, Hitachi-SH und Win32)
* [http://www.rtems.org/ RTEMS]
* [http://code.google.com/p/rt-thread/ rt-thread]
* [http://sourceforge.net/projects/scmrtos/ scmRTOS]
* [http://www.tnkernel.com/downloads.html TNKernel] - "Real-Time-Kernel" TNKernel ist ein kompakter und sehr schneller Echtzeitkernel unter anderem für ARM7 (Philips LPC2106/LPC21XX/LPC22xx, Samsung S3C44B0X, Atmel AT91SAM7S128, STMicroelectronics STR711FR2)
* [http://www.ucos-ii.com/ uC/OS-II RTOS]

=== Hardware (Prototypen-Platinen etc.) ===


* [http://www.armkits.com/ Embest] Philips, Samsung und Atmel ARM Boards und Module, JTAG-Hard- und Software
* [http://www.waveplayer.de/ Embedded-Waveplayer] mit ARM7-Prozessor EP7309 (MIDI- und RS232-Steuerung)
* [http://www.embeddedartists.com/ Embedded Artists] bietet verschiedene preisgünstige Platinen (ab 25 Euro für LPC213x Familie)
* [http://www.embedded-it.de/microcontroller/microcontroller-module.php Embedded-IT] eNet-sam7X: Ethernut kompatible Embedded Ethernet Mikrocontroller Boards für Industrie und Hobby auf ARM mit Nut/OS Betriebssystem sowie USB Module auf AVR Basis
* [http://www.hiteg.com Hiteg] SAMSUNG und Intel XScale basierende boards. (Deutsches Unternehmen in China)
* [http://www.hitex.de/ Hitex] Starter-Kits für Philips LPC2000, ST STR7, Atmel AT91M
* [http://www.iar.com/ IAR] Starter-Kits für Atmel, Oki, Philips, ST und TI
* [http://www.ic-board.de/index.php?cat=c12_ICswift-Module.html ic-board.de] Kommunikationsplattform auf Basis des AT91SAM7X256 mit Ethernet, USB, CAN und Funk Schnittstellen
* [http://www.keil.com/ Keil] Philips LPC2000 und ST STR7/9 Boards und Starter-Kits
* [http://www.lpctools.com/ LPCTools] bietet verschiedene Starter Kits für die LPC2000-Familie
* [http://www.makingthings.com/ MakingThings] Make Controller Kit (AT91SAM7X256)
* [http://mct.de/index.html MCT Paul und Scherer] Starterkits für ARM7 (NXP LPC2000, ADI ADUC7000)
* [http://shop.mikrocontroller.net Mikrocontroller.net Shop] Platinen mit AT91SAM7, LPC2xxx, JTAG
* [http://www.microcontroller-starterkits.de Microcontroller-Starterkits] Starter-Kits für verschiedene Microcontroller (D) preisgünstige Platinen (ab 12,95 Euro für LPC2129 und 2194) sowie Entwicklungsboard komplett bestückt
* [http://stores.ebay.de/Micro-Research Micro-Research] Development- und Header-Boards für LPC2000 und ADuC7000
* [http://www.olimex.com Olimex] Bulgarischer Anbieter günstiger ARM Prototypen- und Header-Boards (LPC2000, STR7, AT91SAM, ADI, TI, OKI u.a.)
* [http://www.propox.com/?lang=en Propox]
* [http://www.mcu-raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer2 from Raisonance] Focus auf STM32 mit sehr grossem Forum im STM32circle
* [http://www.revely.com/ Revely] Evaluations- und Demo-Boards mit Sharp ARM Controllern. Teilweise mit SVGA-Anschluss.
* [http://www.skpang.co.uk/catalog/index.php SKPang electronics] Entwicklungsboards für diverse ARM7/9 (UK)
* [http://www.dilnetpc.com SSV Embedded Systems] bietet verschiedene Starter Kits für die verschiedenen DIL/NetPC u.a. (A)DNP/9200 SBC mit AT91RM9200
* [http://www.taskit.de taskit] [https://www.ledato.de/shop_content.php?coID=10 Development- und Header-Boards für AT91SAM7S/X], AT91RM9200, AT91SAM9
* [http://www.toradex.com/e/products.html Toradex] Colibri: Intel XScale PXA270 DevKit (Schweiz)

== [[PIC]] ==

=== Herstellerseiten ===
* [http://www.microchip.com Microchip] Hersteller der PIC Microcontroller
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en010014&part=SW006011 Microchip C18 Student Edition] - die "Student Edition" des Microchip C18 C Compilers für die PIC18 Serie ist kostenlos verfügbar.
* [http://www.powercontact.de Elektronikentwicklung von Systemtechnik LEBER] Offizieller Microchip Design Partner für professionelles Microcontroller Design und Hersteller von Leistungsstellern, Thyristorstellern und Halbleiterelais...

=== Entwicklungstools / Tutorials / Foren ===
* [http://www.osterer.co.at www.osterer.co.at] Entwicklungs-Board mit integrierten Programmer/Debugger für PIC18F4550.
* [http://www.martins-elektronikwelt.tk www.martins-elektronikwelt.tk] ICD1-Debugger-Nachbau im Kleinstformat u. SMD Technik (so groß wie eine halbe Scheckkarte).
* [http://www.sprut.de/electronic/pic/index.htm PIC-Microchip-Controller (www.sprut.de)] Diese Seite soll dem Anfänger die ersten Schritte in die Welt der Microcontroller der Firma Microchip erleichtern. Betrachtet werden die 14-Bit-Controller der Serien PIC16Fxxx bzw PIC12Fxxx.
* [http://pic-projekte.de/ PIC-Projekte.de] Tutorials (u.a. für PIC C) und Projekte mit erklärten Codesnipseln (geeignet für Anfänger), [http://pic-projekte.de/phpBB3/ deutschsprachiges PIC Forum]
* [http://www.fernando-heitor.de PIC: Programmierung in CCS (www.fernando-heitor.de)] Dies ist eine weitere Seite, die dem Anfänger, der sich mit PICs beschäftigt, auf die Beine hilft. Sie befasst sich hauptsächlich mit dem CCS-Compiler und hat dazu ein sehr gutes Tutorial. Ausserdem bietet die Seite ein Forum speziell für PIC Mikrocontroller.
* [http://www.cc5x.de CC5X] Programmierkurs für PIC-Mikrocontroller in C (CC5X Compiler)] Programmierkurs mit Beispielen und Schaltplänen, fertige Hardware- und Softwarelösungen. In diesem Kurs sind auch einige Unterprogramme detailliert erklärt.
* [http://www.microchipc.com/ MicrochipC.com] Programmieren von PIC-Microcontrollern mit C. (Enthält auch Links und Bootloader für diverse PICs.)
* [http://www.amodio.biz/projects/PIC10BaseT/index.html Internetworking with Microchip Microcontrollers - PIC18F4620+ENC28J60]
* [http://pic18fusb.online.fr/wiki/wikka.php?wakka=WikiHome Wiki about Microchip USB PIC] (PIC18F2550, PIC18F4550...)
* [http://members.aon.at/electronics/pic/picpgm/index.html PICPgm - A free and simple PIC Development Programmer Software for Windows and Linux] Einfacher PIC Programmer für Windows und Linux. Unterstützt eine Vielzahl von PIC-Chips und wird ständig erweitert. Derzeit können PIC10F, PIC12F, PIC16F, PIC18F, PIC24H sowie dsPIC30F und dsPIC33F programmiert werden.
* [http://www.stolz.de.be InCircuit-Programmer und -Debugger (www.stolz.de.be)] Einfacher Nachbau des Microchip ICD2s. Zum Programmieren und Debuggen.
* [http://www.winpicprog.co.uk WinPicProg] Programmer und Tutorials für Anfänger von Nigel Goodwin (Englisch)
* [http://usbpicprog.org/ usbpicprog], an open source Microchip PIC programmer for the USB port. A wxWidgets based (cross platform) application to communicate with the usbpicprog hardware / firmware. This application is known to function well on Linux, Windows (XP or later) and Macosx.
* [http://www.tigal.com EasyPIC3, EasyPIC4, Easy8051A, EasyAVR, Easy-was-weiss-ich (www.tigal.com)] - Distributor für Produkte von [http://www.mikroelektronika.co.yu mikroelektronika] und weiteren Herstellern
*[http://www.pro-zukunft.de Pro Zukunft] Evaluation-Board für PIC16F84A, hands-on-training und Print-Lehrgang. Für Schulen, Ausbildungsbetriebe & Hobbyelektroniker.
* [http://www.wselektronik.at www.wselektronik.at] Bausatz für "Full Speed ICD2" (USB2.0, Debugger, Programmer) oder Fertiggerät erhältlich.
* [http://www.uchobby.com/index.php/2008/04/19/pic-development-linux-style/ How to setup for PIC microcontroller development on Linux] von Steven Moughan
* [http://www.dattalo.com/gnupic/gpsim.html#docs gpsim] is a full-featured software simulator for Microchip PIC microcontrollers distributed under the GNU General Public License.
* [http://www.mtoussaint.de/yapide.html YaPIDE] aims to be a fully featured Microchip PIC simulator for Linux (and probably other UNIXes). YaPIDE is a GUI only application. If you need a commandline based PIC simulator there is the excellent '''gpsim'''. The simulator kernel currently supports the PIC 16F628.
* [http://piklab.sourceforge.net/ Piklab] is an integrated development environment for applications based on Microchip PIC and dsPIC microcontrollers similar to the MPLAB environment. It integrates with several compiler and assembler toolchains (like gputils, sdcc, c18) and with the simulator '''gpsim'''. It supports the most common programmers (serial, parallel, ICD2, Pickit2, PicStart+) and debuggers (ICD2).
* [http://dev.frozeneskimo.com/software_projects:vpicdisasm vPICdisasm] is a Microchip PIC Mid-Range family firmware disassembler. This single-pass disassembler can read Intel HEX and Motorola S-Record formatted files containing valid PIC firmware. (GPL)
* [http://pikdev.free.fr/ PiKdev] is a simple graphic IDE for the development of PIC-based applications. It currently supports assembly language. C language is also supported for PIC 18 devices. PiKdev is developed in C++ under Linux and is based on the KDE environment.
* [http://www.yenka.com/en/Yenka_PICs/ Yenka PICs] lets you write routines using simple flowcharts, and test them on-screen, before using them to program real PIC or PICAXE chips. To help spread the news about Yenka, we're offering free copies of Yenka PICs for use at home or school.
* [http://gcbasic.sourceforge.net/ Great Cow BASIC] "Open Source BASIC programming tools for Microchip PIC and Atmel AVR microcontrollers"
* [http://openprog.altervista.org/OP_eng.html Open Programmer] - An open source [[USB]] programmer for [[PIC]] micros, [[I2C]]-[[SPI]]-MicroWire [[EEPROM]]s, some ATMEL [[AVR]] micros, generic I2C/SPI devices and (soon) other devices. Can work as [[ICD]] debugger.

=== Projektsammlungen/Einzelprojekte ===
* [http://www.martins-elektronikwelt.tk www.martins-elektronikwelt.tk] Viele Projekte mit den PIC Mikrocontrollern, u.a. SMS-Schaltzentrale, SD/MMC-FAT32-MP3-Player, Lichtschranken, Funk-Wetterempfänger, PS/2 am PIC usw.
* [http://www.Firmware-On-Demand.com Firmware-On-Demand] Umfangreiche Firmware-Bibliothek.
* [http://pic-projekte.de/hd44780_c18.html XLCD Librarie] Anleitung zum Ansteuern des HD44780 unter Verwendung der C18 XLCD Librarie
* [http://www.rentron.com www.rentron.com] Anfänger-taugliche Projekte für PIC und [[8051]] von Reynolds Electronics (Englisch)
* [http://www.circuitcellar.com/microchip2007/ Microchip 16-Bit Embedded Control 2007 Design Contest] bei [http://www.circuitcellar.com/ Circuit cellar]
* [http://mondo-technology.com/ Mondo Technologiy] Grosse Ansammlung von PIC-Projekten, u.a. SuperProbe: Logic Probe,(Auf der linken Seite ganz oben) Logic pulser, Frequency Counter, Event Counter, Voltmeter, Diode Junction Voltage, Capacitance Measurement, Inductance Measurement, Signal Generator, Video Patern, Serial Ascii, Midi Note, R/C Servo, Square Wave, Pseudo Random Number, ir38, PWM in einem... (PIC16F870)
* [http://micrognurtos.sourceforge.net uGNU/RTOS] is a microcontroller-targeted serial real time operating system. It has been ported to USART capable Microchip PIC16 devices. It supports I/O operations and some internal registry operations. The user can interact with the chip through the RS-232 serial cable and a shell. The user can type a small list of commands and see the results on the chip's outputs. (LGPL)
* [http://pic-projekte.de www.PIC-Projekte.de] Hier finden sich einige interessante Projekte mit PIC Mikrocontrollern (z.B. Anleitung zum Ansteuern eines HD44780 komp. LCD von eA, Ansteuern eines KS0107/8 Controllers in ASM mit PIC) sowie Erklärungen zu den dazugehörigen Programmabschnitten. Außerdem gibt es eine Anleitung zum Herrstellen von Platinen. Besuchen Sie das [http://pic-projekte.de/phpBB3/index.php PIC-Forum] und diskutieren Sie mit bei spannenden Themen. Wenn Sie Fragen zu PIC µC der Firma Micochip haben, dann sind Sie hier richtig aufgehoben!
* [http://pic16f628a.blogspot.com/ Experiments with PIC16F628A] - PIC Programming in C

*Stevy's Homepage http://stevy.bplaced.com Pic Projekte die in C geschriebn wurden z.B 3D Engine, Grafik Display Ansteuerungen, Oszilloskip usw
* [http://www.simon-brenner.ch/projekte/rgb-led-stripe RGB Stripe mit 16bit Bus, realisiert mit PIC12F629]
* [http://scifi.pages.at/drakesoft/aulem_mypong/ Spiel PONG] auf einer 16x16 LED Matrix mit Ton, realisiert auf einem AVR.
* [http://hackinglab.org/ Pinguino Webpage] und [http://wiki.pinguino.cc/index.php/Main_Page Pinguino Wiki] ist ein Arduino-ähnliches Open Source und Open Hardware Projekt für 8-Bit (PIC18F2550, PIC18F4550) Mikrocontroller.

== [[Z8]] ==
* [http://groups.yahoo.com/group/z8encore/ Yahoo! Groups : z8encore] Yahoo-Gruppe, die sich mit den Z8 Encore! Mikrocontrollern beschäftigt (Anmeldung bei Yahoo erforderlich).
* [[Zilog Encore Experimentierplatine]] (Z8F6421 Familie mit DIP-40 Gehäuse)
*[http://www.thpeter.net Zilog Projekte] (Ein Z8Encore und ZNEO Projekt und viele Tips zum Programmieren und Debuggen)


== Programmierbare Logik ([[CPLD]]/[[FPGA]]/[[GAL]]) ==

* [http://www.opencores.org/ OpenCores.org], VHDL Sourcen
* [http://www.fpga4fun.com/ fpga4fun], umfangreiche Seite mit Einführung und Beispielen, berücksichtigt Xilinx & Altera
* [http://opencollector.org/history/freecore/ Freecore], unter 'Module library' gibt's einige freie Designs
* [http://www.cmosexod.com/ CMOSExod], Designs unter 'Free IP'
* [https://digilent.us/ Digilent], Hersteller verschiedener FPGA/CPLD-Boards (u.a. Xilinx Spartan Starter Kit)
* [http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=39 Terasic], Anbieter von Altera FPGA-Boards
* [http://shop.trenz-electronic.de/catalog/ Trenz Elektronik], verkauft verschiedene FPGA/CPLD-Boards
* [http://www.xess.com/index.html XESS], Anbieter von FPGA-Boards (Xilinx), unter Support gibts es eine Menge Beispiele
* [http://members.optushome.com.au/jekent/FPGA.htm Private Seite von John Kent], enthält eine Menge Links und auch einige Designs
* [http://www.openpicide.org openPICIDE], Picoblaze IDE für Windows, Linux und Mac
* [http://www.mediatronix.com/Tools.htm Mediatronix tools], Picoblaze und DSP tools
* [http://www.ixo.de/info/usb_jtag/ ixo.de usbjtag] - USB-JTAG Adapter, fast kompatibel zu Altera USB-Blaster, wahlweise basierend auf FT245+CPLD oder Cypress FX2 Controller
* [http://www.fpgacpu.org/links.html FPGA CPU Links]
* [http://www.fpga-forum.com/wbb Forum mit allgemeinen Diskussionen zum Thema FPGA und FAQ's speziell zu den Cesys FPGA Karten]
* [http://www.cesys.biz Online Shop für Cesys FPGA Karten]

== DSP ==

* [http://www.tetrix-systems.de/embedded.html combined embedded Linux-DSP Solutions]
* [http://open.neurostechnology.com/node/1020 TI c54x DSP Compilertools (ohne Debugger)] frei für Open Source Projekte.

== Wettbewerbe (Contests) ==

Verschiedene Hersteller veranstalten zur Promotion ihrer Produkte Designwettbewerbe, aus denen teilweise komplette Projektunterlagen hervorgehen (Schaltung, Source).

'''2011'''
*[http://www.555contest.com 555 Contest]
*[http://www.circuitcellar.com/nxpmbeddesignchallenge/ NXP and ARM/mbed challenge]
*[http://www.ebv.com/en/products/stm32-design-contest.html STM32 Design Contest] von EBV Elektronik und STMicroelectronics
* [http://www.renesasrulz.com/community/rx-contest The RX MCU Design Contest] und die Top 3 im [http://www.eevblog.com/2011/06/05/eevblog-174-renesas-rx-design-contest-winners/ Video] bei Dave Jones auf EEVBlog.com
* [http://www.cypress.com/?id=3298 ARM Cortex-M3 PSoC® 5 Design Challenge]
* [http://www.instructables.com/contest/micro/ SparkFun Microcontroller Contest] bis 13.02.2011
* [http://www.elektroniknet.de/bauelemente/news/article/27963/0/Wer_entwickelt_die_beste_Anwendung_mit_dem_EFM32/ EFM32 Design-Wettbewerb] von Elektronik, Avnet-Memec und Energy Micro
* [http://www.freescale.com/webapp/sps/site/overview.jsp?code=KINETIS_MAKEIT_CHALLENGE&tid=vanKINETIS_MAKEIT_CHALLENGE Make It Challenge: Kinetis MCUs] von Freescale

'''2010'''
* [http://www.schmartboard.com/index.asp?page=mcu_2010 SchmartBoard 2010 MCU Challenge]
* [http://www.digilentinc.com/showcase/contests/designcontest.cfm?ContestID=6 Digilent Design Contest 2010]
* [http://www.parallax.com/go/holidaychallenge Parallax & iGen Student LED Holiday Challenge]
* [http://www.embeddedspark.com/upcomingchallenge/ The embeddedSPARK 2010 SUMMER Challenge]
* [http://www.libelium.com/tienda/catalog/contest.php?language=en Libelium Arduino Open Hardware Contest]
* [http://www.circuitcellar.com/designstellaris2010/index.html Texas Instruments DesignStellaris 2010]
* [http://www.wizwiki.net/main/ iMCU Design Contest] (WIZnet)
* [http://www.elo-web.de/elo/entwicklung-und-projekte/ping-pong/elo-programmierwettbewerb-2010 ELO-Programmierwettbewerb 2010] (Atmega8, PingPong-Platine, 31.3.10)
* [http://www.lpc1100challenge.com/ NXP LPC1100 Design Challenge] (Cortex-M0 based LPC1100)

'''2009'''
* [http://arduinofun.com/blog/2009/11/01/fun-with-arduino-contest/ Fun with Arduino Contest]
* [https://www.xmos.com/challenge/ XMOS Challenge]
* [http://www.designmsp430.com/ Design MSP430 Ultra-Low Power Challenge]
* [http://makezine.com/halloweencontest/ Make: Halloween Contest 2009], sponsored by Microchip Technology!
* [http://www.bricogeek.com/contest/let-arduino-play/resultados.php Let Arduino Play Contest]
* [http://www.dlpdesign.com/designcontest/ DLP Design DLP-232PC Design Contest]
* [http://www.libelium.com/tienda/catalog/contest.php Arduino contest by Libelium]
* [http://www.expli.de/wettbewerb/coole-avr-microcontroller-elektronik-ideen/ EXPLI Elektronik Wettbewerb]: Die coolsten Elektronik Projekte & AVR Microcontroller Anleitungen
* [http://www.stm32circle.com/projects/contest.php STM32 Primer2 Design Competition 2009]
* [http://www.parallax.com/Resources/ApplicationsContests/Contests/200910PropellerContest/tabid/846/Default.aspx 2009/2010 Propeller Design Contest]

'''2008'''
* [http://www.parallax.com/tabid/720/Default.aspx Propeller Design Contest]
* [http://www.psocidcindia.com/index.php PSoC Innovator Design Challenge India 2008]
* [http://www.mypic32.com Microchip PIC32 Design Challenge]
* [http://contest.renesasinteractive.com/ HEW Target Server Design Contest 2008]
* [http://www.stm32circle.com/projects/result_contest_2008.php STM32 Primer Design Competition 2008]

'''2007'''
* [http://www.circuitcellar.com/wiznet/index.html WIZnet iEthernet Design Contest 2007]
* [http://www.circuitcellar.com/microchip2007/ Microchip 16-Bit Embedded Control 2007 Design Contest]

'''2006'''
* [http://www.designmsp430.com/View.aspx 2006 MSP430 eZ Design Contest]
* [http://www.luminarymicro.com/DesignStellaris2006 Luminary Micro DesignStellaris2006]
* [http://www.circuitcellar.com/avr2006/ Atmel AVR Design Contest 2006]

'''2005'''
* [http://www.jandspromotions.com/philips2005/index.htm Philips ARM Design Contest 2005] (LPC213x)
* [http://www.circuitcellar.com/renesas2005m16c/index.htm Renesas M16C Design Contest 2005]
* [http://www.edn.com/article/CA516007.html Cornelius van Drebbel's Mad Design Contest] (NEC)

'''2004'''
* [http://www.circuitcellar.com/avr2004/ Atmel AVR 2004 Design Contest]
* [http://www.circuitcellar.com/psoc2004/ PSoC High Integration Challenge 2004]
* [http://www.jandspromotions.com/zilog2004/ Zilog 2004 Flash Nets Cash Design Contest] (eZ80Acclaim!)
* [http://www.jandspromotions.com/wirelesschallenge/index.html 2004 Freescale Wireless Design Challenge] (MC13191/92/93 RF Transceivers, [[Meshnetics Zigbee|ZigBee]])

'''2003'''
* [http://www.circuitcellar.com/fi2003/ MOTOROLA FLASH INNOVATION 2003 DESIGN CONTEST] (Motorola HC08)
* [http://www.circuitcellar.com/renesas/ Renesas H8 Design 2003 Contest]
* [http://www.jandspromotions.com/zilog2003/ ZiLOG Flash for Cash Z8 Encore®! International Design Contest]
* [http://www.jandspromotions.com/efield203/index.htm 2003 Motorola E-Field Sensor Contest] (MC33794)

'''2002'''
* [http://www.circuitcellar.com/flash2002/ Mad Dash for Flash Cash] (Microchip, PIC)

'''2001'''
* [http://www.circuitcellar.com/dl2001/ Atmel 'Design Logic 2001' Design Contest]
* [http://www.circuitcellar.com/msp430/ MSP430 Design Contest]

== Interfaces & Protokolle ==
Siehe auch [[Linksammlung#Schnittstellen]]

=== Infrarot (IR) ===

* [http://www.sbprojects.com/knowledge/ir/index.php Übersicht IR-Protokolle] von San Bergmans (engl.): ITT, JVC, NEC, Nokia NRC17, Sharp, Sony SIRC, Philips RC-5, RC-6, RC-MM, RECS80, RCA, X-Sat
* [http://www.vishay.com/docs/80071/dataform.pdf Data formats for IR controls (PDF)] von Vishay.
* [http://www.ostan.cz/IR_protocol_analyzer/ IR protocol analyzer] (Freeware)

=== Parallelport ===

* [http://www.projects-lab.com/?p=1139 ECPMON] - ECP Parallel Port Monitor ([[M16C]]/62P)

=== iPod ===
* [http://ipodlinux.org/IPod_to_T%26A_remotecontrol_adapter IPod to T&A remotecontrol adapter] ([[PIC]]-Projekt)(Link defect)
* http://jasongarr.wordpress.com/project-pages/ipod-clickwheel-hack/

=== [[RFID]] ===

* [http://www.alexanderguthmann.de/RFIDemulator.html RFIDemulator] - Beschreibung eines RFIDemulators zum klonen von Tags
* [http://www.mwjournal.com/journal/article.asp?HH_ID=AR_905 Radio Frequency Identification: Evolution of Transponder Circuit Design] - Übersichtsartikel aus dem Microwave Journal
* [http://www.foebud.org/rfid Die StopRFID-Seiten des FoeBuD e.V.]
* [http://www.rfzone.org/free-rf-ebooks/ PDF-Bücher (englisch) ]- Bücher über RF, Antennen und elektromagnetische Wellen.

* http://cq.cx/proxmark3.pl Jonathan Westhues RFID Leser/Schreiber/Cloner

http://www.message_bocracco.com/

==== ~ 125 kHz ====

*[http://t4f.org/en/projects/open-rfid-tag Open RFID Tag]

==== 13,56 MHz RFID ====
* [http://www.openpcd.org/ OpenPCD - a free 13.56MHz RFID reader design] for Proximity Coupling Devices (PCD) based on 13,56MHz communication. This device is able to screen informations from Proximity Integrated Circuit Cards (PICC) conforming to vendor-independent standards such as ISO 14443, ISO 15693 as well as proprietary protocols such as Mifare Classic. (AT91SAM7S128 [[ARM]] Projekt)
* [http://www.rf-dump.org/ RFDump] is a backend GPL tool to directly interoperate with any RFID ISO-Reader to make the contents stored on RFID tags accessible. (Linux)

==== 2,4 GHz RFID ====
* [http://www.openbeacon.org/ OpenBeacon] - a free active 2.4GHz beacon design. (Reader: USB oder Ethernet; Tags: RF_Chip: NRF24L01, PIC16F684)

=== [[DMX512]] ===
* [http://www.soundlight.de/techtips/dmx512/dmx512.htm DMX-512 - was ist das?] Eine Übersicht von SOUNDLIGHT.
* [http://dworkin-dmx.de/ USB DMX Interface] Bausatz /Fertiggerät USB DMX Interface
* [http://www.oksidizer.com/electronic/spp2dmx/index_en.html OksiD DMX 3/1 is a Standard Parallel Port DMX 512 interface for IBM compatible PCs]. Drei Output Universe und ein Input Universe (Universe = 512 channels). Open project. All source code and schematics are available for free.
* [http://www.usbdmx.com/usb_dmx_interface.html USB DMX Interface revision 1.3] - opto isolated, bus powered, DMX512 from/to [[USB]]interface with both in and out universes. Cheap and simple to build.
* [http://www.dmx512-online.com/ Ujjal's DMX512 Seite]
* [http://llg.cubic.org/dmx4linux/ DMX4Linux 2.6] - A DMX device driver package for Linux (incl. hardware schematics with TI [[MSP430]])

=== Verschiedenes ===
* [http://www.taelektroakustik.de/deu/index.htm T&A Kommandos] - '''RC''' und '''RCII''' Kommandoset der Philips PRONTO Familie zur Steuerung von Audiogeräten. Dokumentation siehe unter Downloads.
* [http://www.marjorie.de/ps2/ps2_protocol.htm Das PS/2 Maus und PS/2- oder AT-Tastatur-Protokoll] (Original auf [http://www.computer-engineering.org/])
* [http://www.hth.com/snap/ S.N.A.P - Scaleable Node Address Protocol]. S.N.A.P is an free and open network protocol. The protocol was primary developed for PLM-24 based home automation and control systems but it is a generic protocol and not limited to this. S.N.A.P can be used in any type of applications where an easy to learn and light weighted network protocol is needed.
* [http://www.ulrichradig.de/home/index.php/avr/avr_-_rc PPM / PWM Encoder/Decoder für R/C Funkfernsteuerungen] von Ulrich Radig (AVR, C)
* [http://www.national.com/analog/interface/lvds_owners_manual LVDS Owner's Manual - 4th Edition] von National Semiconductor
* [http://www.mictronics.de/?page=becker Becker Unilink]
* [http://users.ntplx.net/~andrew/sony/unilink/ Sony UniLink]
* [http://www.vending.org/technology/MDB_Version_4.pdf Multi-Drop Bus / Internal Communication Protocol (MDB / ICP)]

== Elektronikversender‎ ==

siehe [[Elektronikversender‎]]

== Leiterplattenhersteller ==

siehe [[Platinenhersteller]]

== Schulungen (Online) ==

* [http://www.esacademy.com/myacademy/ www.esacademy.com] (engl.) - C, CAN, I²C, BlueTooth, PWM, USB, 51LPC, ARM (Einführung)
* [http://www.elprak.ch Elektronik in der Praxis] Präsentationen zu verschiedenen Themen der Elektronik in der Praxis. Lötvideo, das den zeitlichen Ablauf beim Löten anschaulich darstellt.
* [http://www.national.com/onlineseminar/ www.national.com] - Amplifiers, Audio, Data Acquisition, Die Products, Displays, Interface, Microcontrollers, Military/Aerospace, Power, Thermal Management, Wireless
* [http://www.circuitrework.com Circuit Technology Center] - Surgeon grade rework and repair, by the book and guaranteed. Deeplink: [http://www.circuitrework.com/guides/guides.shtml Guides]
* [http://www.onlinetutorials.de/index.htm onlinetutorials.de] - Linksammlung zu Tutorials für höhere Programmiersprachen ([[HLL]]) wie C, C++, Java, BASIC, Perl, PHP, ...
* [http://www.awce.com/classroom/ AWCE Interactive Classroom] - Embedded Systems (Using the APP-IV with GCC, Getting Started with the PIC 18F Family), Electronics (CLARC/HBSIG DSP Study Group, Basic Circuits), RoadMap to Programmable Logic
* [http://www.ibiblio.org/kuphaldt/socratic/ Socratic Electronics] (englisch)
* [http://www.embedded.com/design/multicore/201200638;jsessionid=4T1T0OZQW4PFSQSNDLRSKH0CJUNN2JVN?printable=true The basics of programming embedded processors] von Wayne Wolf. Neun Artikel bei embedded.com (englisch)
* [http://webcast.berkeley.edu/course_details.php?seriesid=1906978507 EE 42/EE 100 Introduction to Digital Electronics] - Webcast, Spring 2008 (englisch)
* [http://freevideolectures.com freevideolectures.com] - Webcasts zu naturwissenschaftlichen Theman (englisch)
* [http://www.circuitsage.com/ Circuit Sage], a complete source of information to help you design circuits fast. (Linksammlung zu Software, Artikeln Büchern und Websites)
* [http://www.DieElektronikerseite.de Die Elektronikerseite] Umfangreiche Sammlung von kleinen Lehrgängen und Schaltungen. Ideal für Anfänger aber auch für Fortgeschrittene
* [http://homepages.internet.lu/absolute3/tronic/ 3D Virtual Development] - Sammlung von vielen Grundschaltungen im Bereich Oszillator, Operationsverstärker, Empfangstechnik. Vereinzelt in Englisch.
* [http://cws.gtc.edu/programs/objects/electronics.htm Learning Objects for Electronics] des Engineering Tech Wing of Gateway Technical College (Flash erforderlich)
* [http://ecee.colorado.edu/~bart/book/book/title.htm Principles of Semiconductor Devices] von Bart Van Zeghbroeck
* [http://itp.nyu.edu/physcomp/Intro/HomePage Introduction to Physical Computing] ([[AVR]], Arduino)

== Skripte ==

* [http://www.janson-soft.de/skripte/index.html Linksammlung von Volker Lange-Janson]
* [http://wwwex.physik.uni-ulm.de/lehre/physikalischeelektronik/phys_elektr/phys_elektr.html Physikalische Elektronik und Messtechnik] von Othmar Marti und Dr. Alfred Plettl, Universität Ulm
* [http://openbookproject.net//electricCircuits/index.htm Lessons in Electric Circuits I-VI] von Tony R. Kuphaldt

== Messequipment ==
* [http://www.filmetrics.com Filmetrics Inc.] (Filmetrics manufactures affordable thin-film measurement instruments capable of measuring thin films from 3nm to 0.5mm in thickness.)
* [http://www.pce-instruments.com PCE Instruments] (Entwicklung und Produktion für Prüfgeräte und Waagen.)
=== Logikanalyse ===
* [http://www.pctestinstruments.com Intronix LogicPort], Günstiger, aber sehr leistungsfähiger Logikanalysator mit USB-Anschluß an PC (34Ch, 500MHz Timing, 34 x 2kSa mit Kompression, ca. 295 Euro [http://www.shop.display3000.com/elektronik/messgeraete/index.html hier])
* Zeroplus LAP-Cxxxx (Familie von LA's mit unterschiedlichen Daten, 32kBit...2MBit, 16ch oder 32ch, 100MHz..200MHz, Preise von 90,-...1100,- Euro, zu kaufen [http://www.tigal.com/products_category.asp?cid=96 hier])
* [http://www.tech-tools.com/dv_main.htm TechTools DigiView], Günstiger Logikanalysator mit USB-Anschluß an PC (18Ch, 100MHz Timing, 128kSa mit Kompression, [http://elmicro.com/de/digiview.html ca. 430Euro])
* [http://www.tribalmicro.com/logic_an/ Tribalmicro], PC hosted LA (32ch, 40MHz Timing, 128kSa, ca. 1700$)
* [http://www.nci-usa.com/frame_products_overview.htm NCI GoLogic], Logikanalysator mit USB-Anschluß an PC (34 oder 72Ch, 500MHz Timing, 1 oder 2MSa, ca. 3000..5500$)
* [http://www.tek.com/products/logic_analyzers/index.html Tektronix], Verschiedene Geräte, standalone oder modular (ab 34ch, 2GHz Timing, ab 512kSa, gut und teuer)
* [http://www.home.agilent.com/DEger/nav/-536902443.0/pc.html Agilent], Verschiedene Geräte, standalone, modular oder PC-hosted (ab 34ch, ab 800MHz timing, ab 256kSa, gut und teuer)
* [http://www.sump.org/projects/analyzer/ Sumps LA], günstiges Projekt für einen LA basierend auf einem Digilent Spartan Board (32ch, 100MHz Timing, 256kSa, Kosten Digilent Board ca. 100$ + Versand/Zoll)
* [http://www.meilhaus.de/produkte/usb-mobile-messtechnik/?user_produkte%5BPATTR%5D=HPG_3-UPG1_3-UPG2_2&user_produkte%5BPR%5D=8&cHash=2c8edb93e2 Meilhaus Electronic - MEphisto Scope UM203] Robustes, mobiles 16 bit Kombi-Instrument 7 Mess-Geräte in einem! (ab 348€)
* [http://www.hacker-messtechnik.de/13722/59001.html TravelLogic TL2x36], Logikanalysator zum Anschluß an PC über USB, (36ch, 4GHz timing, 200MHz state, Speicher bis 72MBit, Preis ab ca. 500,- netto)
* [http://www.inovaflex.de/index.html Bus und Logic Analyzer] 100MHz Samplerate und integrierten SPI, I²C, CAN Interpreter, erweiterbar als Oszilloskop
* [http://www.saleae.com/logic/ logic] - Logik-Analyzer mit 8 Kanälen, mit Software zur Analyse von SPI, I2C, UART, etc... (ca 150$ + Versand/Zoll)
* [http://www.deditec.de/de/logikanalysatoren/prod/usb-logi-500.html DEDITEC USB-LOGI-500], kostengünstiges Einsteigermodell mit USB-Anschluß und dazugehöriger Software Logi+ (36Ch, Abtastrate 500MHz, 4096 Samples Speichertiefe/Kanal, ca. 236 Euro)

* Eine Übersicht über verschiedene Selbstbauprojekte: [[Logic_Analyzer]]

* [http://www.timing-diagrams.com TimingAnalyzer] can be used to easily draw timing diagrams and perform timing analysis to find faults in digital logic systems. Written in Java, it runs on any platform that supports the Java Run-time Environment, JRE1.6.0 or Java Development Kit JDK1.6.0 or newer.

=== Oszilloskope ===

siehe die separate [http://www.mikrocontroller.net/articles/Oszilloskop Seite] zum Thema

=== Generatoren ===
[http://www.meilhaus.de/produkte/mess-und-steuer-karten/?user_produkte%5BPR%5D=23&cHash=64a269a3c6 Meilhaus Electronic - ME-6x00] Waveform-Generator - potentialfrei isolierte 16 bit Analog-Ausgabe-Karte (ab EUR 1138,00)

=== Handbücher für Messgeräte ===
Für ältere kommerzielle Messgeräte sind viele Handbücher im Web als PDF verfügbar. Hier eine Linkliste für den kostenlosen Download:
* [http://www.ko4bb.com/cgi-bin/manuals.pl KO4BB Didier Juges]
* [http://bama.edebris.com/manuals/ BAMA-Edebris (mirror)]
* [http://www2.faculty.sbc.edu/kgrimm/boatanchor/index.htm BAMA Originalseite K4XL]
* [http://www.to-way.com/teqman.html to-way.com (K7MLR)]
* [ftp://ftp.bluefeathertech.com/pub/electronics/testgear/ Bluefeathertech FTP-Server]
* [http://www.bitsavers.org/ Bitsavers, vor allem Computermanuals und Software]
* [https://www.logsa.army.mil/etms/online.cfm Handbücher der US-Army (->"i accept" -> "Enter the site" -> Suchbegriff z.B "Analyzer" in "Pub Title Text" eingeben -> search)]
* [http://www.eserviceinfo.com/browse.php eserviceinfo.com]
* [http://www.one-electron.com/FC_TestEquipment.html one-electron.com]
* [http://manoman.sqhill.com/ manoman]
* [http://www.nostalgiaair.org/ Nostalgia Air schematics, manuals, tube data]
* [http://pages.cthome.net/fwc/ Freds sehr alte (vor allem Militärelektronik-) Geräteliteratur, Röhrentechnik] und hier [http://pages.cthome.net/fwc/TO-DOC.HTM Übersicht zur Nummerierung der Militärhandbücher]
* [http://www.hpmemory.org/ressources/resrc_home.htm HP-Memory.org, alte Applications und HP-Journals]
* [http://www.ebaman.com/index.php/home Ebaman Registrierung per e-Mail erforderlich]

Eine [http://www.slack.com/elec.html Linksammlung zu Messgeräten], sehr ausführlich

== Vermischtes ==

=== Foren ===
* [http://forum.sparkfun.com/ Spark Fun Electronics] MicroController Ideas and Support (Englisch) ([[AVR]], [[PIC]], [[MSP]], [[ARM]], OpenOCD)
* [http://www.edaboard.com/ EDAboard.com] International Electronics Forum Center (Englisch)
* [http://stsboard.de STS Reparatur Forum] Forum für Radio und Fernsehtechniker
* [http://formu.iwenzo.de Elektronik Reparatur Forum] Informationselektroniker Reparatur Forum
* [http://www.elektrikforum.de Elektrik-Forum] Forum zum Thema Elektroinstallationen
* [http://www.eeweb.com/electronics-forum/ Electronics Forum] Electrical Engineering Community Forum (Englisch)

=== Videocasts und Podcasts ===

* [http://www.eevblog.com/ EEVblog] Electronics Engineering Video Blog von David L. Jones (englisch). ''Anm.: David ist Australier und das hört man. An die Sprechweise kann man sich aber gewöhnen. Und nicht erschrecken, wenn öfter mal ein drastisches Fourletterword auftaucht!''
* [http://www.theamphour.com/ The Amp Hour] Podcast mit Chris Gammell und David Jones (englisch)

=== Projektsammlungen ===
Meist in Englisch.
* [http://circuitscout.com/ Circuit Scout] - Online Suchmaschine
* [http://www.epanorama.net ePanorama.net]

* [http://www.discovercircuits.com Discover Circuits] a collection of 25000+ electronic circuits or schematics
* [http://www.next.gr/ Next] Electronic Circuit Database
* [http://www.beyondlogic.org/ BeyondLogic.org] Diverse Mikrocontroller und Interfacing Projekte
* [http://www.uoguelph.ca/~antoon/circ/circuits.htm Circuits for the Hobbyist] by VA3AVR
* [http://www.stefpro.de/ StefPro.de] Diverse Projekte und Datenblattsammlung nach Kategorien, Microcontroller, Digital und Analog... Sowie Tutorial "Grundlagen der Bestückung von Platinen" und anderes Wissen
* [http://www.schaltplaene-online.de/ www.schaltplaene-online.de] Umfangreiche Linksammlung zu Schaltplänen aller Art
* [http://www.halloweenmonsterlist.info/ MoNsTeRlIsT of Halloween Projects]
* [http://www.open-innovation-projects.org Open Innovation Projects] - Sammlung von offenen Projekten zu physischen Produkten, darunter etliche Mikrocontroller-Projekte. Man kann selber Projekte hinzufügen.

=== Referenzen, Beschreibungen, Standards ===
* Extraseite: [[Datenblätter]]
* [http://www.technick.net Technik.Net] Pinouts, Circuits and Guides
* [http://pinouts.ru/ pinout.ru] und [http://www.hardwarebook.info/ hardwarebook.info] - Online handbooks of hardware pinouts, cables schemes and connectors layouts
* [http://www.networktechinc.com/technote.html Keyboard, Monitor & Mouse Pinouts] for PC, SUN, MAC, USB, FireWire, RS232, Digital Flat Panel and EVC configurations
* [http://www.q1.fcen.uba.ar/materias/iqi/joygus/tvgames.html Special joysticks used in TV games]
* [http://microsym.com/editor/assets/intelhex.pdf Intel-Hex-Format (PDF)]
* [http://home.teleport.com/~brainy/fat32.htm FAT32 Structure Information] - Written by Jack Dobiash
* [http://www.pjrc.com/tech/8051/ide/fat32.html Understanding FAT32 Filesystems] mit Beispielen (engl.)
* [http://www.rev-ed.co.uk/docs/picaxe_manual3.pdf Microcontroller Interfacing Circuits] - Revolution Education Ltd.
* [http://www.digchip.com/application-notes/ Datenbank für ''Application Notes''] bei www.digchip.com
* [http://www.pavouk.org/hw/lamp/en_index.html#bigluz20w Compact Fluorescent Lamp (CFL)], Schaltungen von Energiesparlampen

=== Online-Bücher ===
* [http://www.allaboutcircuits.com/ All About Circuits] - Series of online textbooks covering electricity and electronics. The information provided is great for both students and hobbyists who are looking to expand their knowledge in this field. (Englisch)
* http://www.computer-books.us/ - überwiegend zu höheren Programmiersprachen. Englisch.
* [http://www.vias.org/feee/index.html FEEE - Fundamentals of Electrical Engineering and Electronics]
* [http://www.nrbook.com/a/bookcpdf.php Numerical Recipes in C, Second Edition (1992)]
* [http://www.specamotor.de/freebook.php Electrical drives for precision engineering designs] Prof.dr.ir. Compter
* [http://www.joretronik.de/Web_NT_Buch/Vorwort/Vorwort.html Das neue InterNetzteil- und Konverter-Handbuch] Dipl.-Ing. Jörg Rehrmann

=== Bedienungsanleitungen / Manuals ===
* [http://bama.edebris.com/manuals/ BAMA Archiv]
* [http://www.big-list.com/ Big-List.com] - This is a directory of over 600 dealers in used high technology equipment. Most deal in used electronic test equipment or semiconductor production equipment. Included are dealers in related high technology items, rental companies, equipment auction sites, test equipment manual dealers, foreign (non-U.S.) used equipment dealers, cal labs, and repair services.

=== Ungewöhnliche Basteleien (Hacks) ===
Auf eigene Gefahr und nicht immer ganz ernst... Meist in Englisch.

* Metablogs (tägliche News)
** [http://www.makezine.com/ Makezine]
** [http://www.hackaday.com/ Hack a Day]
** [http://www.hackedgadgets.com/ HackedGadgets]
** [http://www.hacknmod.com/ Hack N' Mod]
** [http://zedomax.com/blog/category/diy/ Zedomax DIY]
** [http://digital-diy.com Digital-DIY]
** [http://dangerousprototypes.com Dangerous Prototypes]

* Foren
** [http://www.fingers-welt.de/home.htm Fingers elektrische Welt]
** [http://forum.hackedgadgets.com/ HackedGadgets Forum]
** [http://stsboard.de Reparatur Forum]


* Projektsammlungen
** Final Projects der Kurse [http://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/ ECE4760] (Designing with Microcontrollers) und [http://people.ece.cornell.edu/land/courses/ece5760/FinalProjects/ ECE5760] (Advanced Microcontrollers) an der Cornell University
** [http://www.coolcircuit.com/gadgets/ Cool Circuit]
** [http://www.electronics-lab.com/blog/ Electronics-Lab.com Blog]

* DIY-Anleitungen
** [http://www.instructables.com/ instructables]
** [http://www.scitoys.com/ Scitoys] You Can Make With Your Kids

* Mix
** [http://www.evilmadscientist.com Evil Mad Scientist Laboratories] - u.a. The Flying Spaghetti Monster, on toast ;-)
** [http://home.earthlink.net/~lenyr/index.html Spark, Bang, Buzz and Other Good Stuff] ([http://www.sparkbangbuzz.com Neue Sachen])
** [http://www.electricstuff.co.uk/ Mike's Electric Stuff] - Antique Glass, Tesla coils and high-voltage stuff, Lasers
** [http://electricity.pbwiki.com/ DHS electricity]
** [http://www.elephantstaircase.com/wiki/index.php?title=Main_Page Elephant Staircase]
** [http://mycpu.eu Eine selbstgebaute CPU aus TTL-Gattern]
** [http://www.knollep.de/ Knolles Bauanleitungen]
** [http://www.ikalogic.com/index.php ikalogic.com]
** [http://www.electronicsinfoline.com/ Electronics Infoline]
** [http://www.uchobby.com/ uC Hobby]
** [http://elettrolinux.com elettrolinux] - Elektronik und Linux (engl.)
** [http://electronicfox.at.tf/ electronicfox] - Verschiedene Projekte mit [[AVR]], Fernbedienungen und deren Aufbau sowie Decoder und alten ICs aus dem Recyclinghof
** [http://www.techfocusmedia.net/archives/fresh-bytes/ Fresh Bytes von Techfocusmedia]

=== Zeitschriften über Elektronik und µC ===
* [http://www.eue24.net/ E&E Faszination Elektronik] - Magazin für Elektronik-Entwickler und Elektronik-Interessierte
* [http://www.embedded.com embedded.com] - Hauptaugenmerk auf die Philosophie drumherum
* [http://www.siliconchip.com.au/ Silicon Chip] - Freie Artikel unter ''Free Preview''
* [http://www.circuitcellar.com/ Circuit Cellar] - Freie Artikel unter ''Digital Library''
* [http://www.elektronikpraxis.vogel.de/themen/hardwareentwicklung/mikrocontrollerprozessoren/ Elektronikpraxis - Das professionelle Elektronikmagazin]
* [http://www.funkamateur.de/ FUNKAMATEUR] - Elektronik, Amateurfunk, CB-Funk u. v. a. m.
* [http://www.edn.com/ EDN] (etwas schwer zu finden, aber lesenswert: die [http://www.edn.com/channel/Design_Ideas.php Design Ideas] und das [http://www.edn.com/archive/ Archiv der Druckausgaben])
* [http://www.franzis.de/elo-das-magazin ELO - Das Magazin] für Elektronik-Einsteiger
* [http://techonline.com/ TechOnline]
* [http://www.elektor.de/ Elektor]
* [http://www.techbriefs.com/tech-briefs/electronics-techbriefs NASA Tech Briefs] - Electronics & Computers
* [http://et.nmsu.edu/~etti/ Technology Interface Journal]
* [http://dev.emcelettronica.com/ Your Electronics Open Source]
* [http://www.element-14.com element14.com] is an information portal and community specifically built for electronic design engineers.
* [http://www.itwissen.info ITWissen.info] (gutes Lexikon)
* [http://www.nutsvolts.com Nuts'n'Volts] Amerikanisches Elektronikmagazin mit Online Blog
* [http://de.rs-online.com/web/generalDisplay.html?id=eTech eTech] von RS Online

Temperatursensor

2011-11-28T19:12:10Z

Mthomas: /* ADT7310 */

Will man mit einem [[Mikrocontroller]] Temperaturen messen, dann braucht man
* einen [[Sensor]], der die Temperatur z. B. in eine Spannung oder einen Strom umsetzt
* einen [[ADC | AD-Wandler]], der das Signal digitalisiert. Der kann auf dem Sensor oder dem Mikrocontroller integriert sein.

Temperatursensoren gibt es nun in allen möglichen Varianten. Vom temperaturabhängigen [[Widerstand]] bis zum fertig abgeglichenen All-in-one-Bauteil mit digitalem Ausgang. Wie bei allen Sensoren sollte man auch hier genau hinschauen und [[Auflösung und Genauigkeit]] unterscheiden.

== Analoge Temperatursensoren ==

=== PT100 ===

Unter einem PT100 versteht man einen Platinwiderstand, der bei 0°C einen Widerstand von 100Ω hat.
Platinwiderstände sind temperaturabhängige Widerstände mit hoher Wiederholgenauigkeit und Konstanz[http://de.wikipedia.org/wiki/Konstante]. Wegen der relativ geringen Widerstandsänderung von nur ca. 0,4Ω pro Grad ist etwas mehr Schaltungsaufwand erforderlich als bei anderen Sensoren. Genauere Formeln zur Temperaturbestimmung gibt es u.a. bei der [http://de.wikipedia.org/wiki/Pt100 Wikipedia]. Ein Schaltplan findet sich bei der [http://www.heise.de/ct/artikel/Sensibelchen-289608.html c't].

Die Sensoren gibt es auch mit anderen Widerstandswerten, z. B. mit 1000Ω und heißen dann entsprechend PT1000.

Vorteil:
* genormt
* großer Meßbereich
* hohe Linearität
* hohe Wiederholgenauigkeit
* einfach austauschbar

Nachteil:
* relativ teuer (bei segor.de ab 3,80€)
* brauchen aufwendigere Auswerteschaltung

Links:
* [http://www.heise.de/ct/04/22/236/ c't-Artikel: Mikrocontroller-Programmierung: Timer, Sensoren und Drehgeber (mit PT100 Schaltung)]
* [http://pdfserv.maxim-ic.com/en/an/AN3450.pdf Maxim AN3450 Positive Analog Feedback Compensates PT100 Transducer]

=== NTC/PTC ===

NTC und PTC sind temperaturabhängige Widerstände.

* NTC (engl. '''N'''egative '''T'''emperature '''C'''oefficient, Heißleiter), hat bei hohen Temperaturen seinen niedrigsten Widerstand, z. B. Silizium
* PTC (engl. '''P'''ositive '''T'''emperature '''C'''oefficient, Kaltleiter), hat bei niedrigen Temperaturen seinen geringsten Widerstand, z. B. Glühlampe

Um den Widerstandswert zu messen schaltet man sie mit einem normalen Widerstand oder einer [[Konstantstromquelle]] in Reihe zu einem [[Spannungsteiler]] und misst den Spannungsabfall. Eine Beispielschaltung findet sich [http://www.mathar.com/msp_thermo1.html hier].

Vorteil:
* billig (z.B. [http://www.reichelt.de/?ARTICLE=9594 KTY81-110] bei Reichelt ~0,60€)

Nachteil:
* müssen für höhere Genauigkeiten abgeglichen werden
* brauchen A/D-Wandler
* sind nichtlinear

Beispiele:
* KTY10-5
* KTY13-6
* KTY81-121
* KTY81-122

Links:
* [http://www.sprut.de/electronic/temeratur/temp.htm Temperaturabhängige Stromquelle und NTC/PTC inclusive Linearisierung]
*[http://www.umnicom.de/Elektronik/Mikrokontroller/Atmel/AtFan/AtFan.html#2.2.2 Berechnung des Linearisierungswiderstandes für gewünschten Temperaturbereich] der fällt sonst immer vom Himmel
* [http://www.mikrocontroller.net/topic/208587#2065880 KTY 10-5 Formelprobleme]
* [http://www.mikrocontroller.net/topic/225563 Codesammlung: Beispiel mit 0,5°C Auflösung]

=== LMx35 ===

Eine IC-Familie, die pro Kelvin Temperaturänderung ihre Ausgangsspannung um 10 mV ändert. Die ICs gibt es in verschiedenen Genauigkeiten und Temperaturbereichen mit den Bezeichnungen LM135(A), LM235(A) und LM335(A). Der günstigste ist der LM335 mit einem Temperaturbereich von −40 … +100°C.
In verschiedenen Bauformen erhältlich. Beispielschaltungen finden sich im [http://www.national.com/ds.cgi/LM/LM135.pdf Datenblatt] und [http://www.suessbrich.info/elek/elektherm1.html hier]

Vorteile:
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)
* relativ billig (LM335 bei Reichelt ab 0,50 €)

Nachteile:
* benötigt A/D-Wandler
* bei längerer Anschlussleitung störanfällig

=== LM334 ===

Ein IC ähnlich dem LM335 mit dem Unterschied, dass der durch das IC fließende Strom proportional von der Temperatur abhängt. Mit einer einfachen Schaltung aus nur zwei Widerständen kann man dann den Strom in einer Weise wandeln, dass pro Kelvin eine Spannungsänderung von 10mV ausgegeben wird. Da die Strom-Spannungswandlung auf der Platine (und damit nahe am AD-Wandler) stattfindet und die Übertragung des Messwerts durch einen Strom stattfindet, sind Störungen durch Netzbrumm etc. viel geringer als beim LM335

Vorteile:

* relativ billig ([http://www.reichelt.de/?ARTICLE=10468 Reichelt 0,54 €])

Nachteile:
* benötigt A/D-Wandler
* Bereich 0°C-70°C

Ähnliche ICs:
* AD592 (Ausgangsstrom 1µA pro Kelvin, absolute Temperatur) [http://www.reichelt.de/?ARTICLE=3825 Reichelt: 3,75 €], Conrad 174912 8,50 €

=== SMT160-30 ===

Ist ein Zwischending zwischen Digital und Analog. Sein Ausgangssignal ist ein digitales PWM-Signal, zu dessen Messung man am besten den Input-Capture-Eingang eines Mikrocontrollers verwendet. Man kann ihn also wie einen analogen Sensor nur indirekt auslesen, anstatt über einen AD-Wandler hier über einen Timer.

Vorteile:
* Digitales PWM-Signal ist unempfindlich gegen Störeinflüsse
* gibt es in SO8, TO18, TO92 und TO220, gut befestigbar, z.B am Kühlkörper
* linear
* kein Abgleich nötig

Nachteile (viele):
* benötigt Timer
* jittert extrem, genaue Messungen nur über Mittelung / Filterung möglich
* nicht nur das PWM-Verhältnis, sondern auf die Frequenz ist temp-abhängig (1-4kHz)
* teuer (Farnell 10,90€ +16%, Conrad 9,xx€ , www.hy-line.de ??).
* TO92 Gehäuse ist günstiger, dafür weniger genau

Links:
* http://www.hy-line.de/co/sensor-tec/hersteller/smartec/smt-160-30/index.html

=== Thermoelement ===

Ein Thermoelement besteht im einfachsten Fall aus zwei ungleichen Metallendrähten, die an einem Punkt miteinander verbunden sind und bei dem die Verbindungsstelle einer anderen Temperatur ausgesetzt ist als die offenen Enden der Drähte. An den offenen Enden der Drähten entsteht eine Spannung (Thermospannung). Dieser Effekt wurde 1821 von Thomas Seebeck entdeckt ([http://de.wikipedia.org/wiki/Seebeck-Effekt Seebeck-Effekt] bei Wikipedia). Eine weitere Anwendung ist der thermoelektrische Generator ("Thermogenerator").

Vorteil:
* über einen sehr weiten Temperaturbereich einsetzbar

Nachteil:
* die sehr geringen Temperaturspannungen im Mikrovoltbereich benötigen eine sehr gute Auswertelektronik (guter Analogteil + AD-Wandler).

Links:
* [http://digital.ni.com/worldwide/germany.nsf/web/all/7A4F02BAEFEC22AC802567F6003E0D6E Temperaturmessung mit Thermoelementen] - Eine Einführung von David Potter (deutsche Überarbeitung: G.Sinkovic) (inkl. Erläuterung der Kaltstellenkompensation)
* [http://www.sensorwell.at/fileadmin/templates/images/data_sheets/temperatur_messtechnik.pdf Warum Thermoelemente Relativtemperaturen messen! oder Was ist eine Kaltstelle?] - Technische Information von www.sensorwell.at (PDF, ca. 600kB)

== Digitale Temperatursensoren ==

=== DS1621 ===

Der DS1621 ist Temperatursensor und A/D-Wandler in einem. Er gibt seine Daten per [[I²C]]-[[Bus]] aus. Ein Schaltplan für einen elektronischen Thermometer mit diesem IC findet sich [http://www.myplace.nu/avr/thermo/ hier].

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* da I²C ein Bus ist, kann man mehrere DS1621 und andere I²C-Bausteine zusammen anschließen und braucht dafür trotzdem nur zwei I/O-Ports.
* Messbereich -55°C to +125°C
* Genauigkeit +-0,5°C
* Auflösung besser 0,01°C, wenn man die beiden Zählerregister (Count-Remain und Count-per-C) auswertet

Nachteile:
* teuer (Segor 5,80€; RS 3,95€; Conrad 5,22€)
* obwohl die meisten Register [[Speicher#NVRAM | nichtflüchtig]] sind, kann man ihn nicht als Stand-Alone-Thermostat einsetzen, da er erst nach einem Start-Conversion-Befehl zu messen beginnt.

Nachfolger:
* DS1631, DS1631A (Auto-Start-> Stand-Alone-Thermostat), DS1731
* weitere Stand-Alone-Thermostaten: DS1821, DS1629

=== LM75 ===

Der LM75 ist so ähnlich wie der DS1621, allerdings nur in SMD erhältlich und nicht so genau. Er ist aber öfters mal auf PC-Mainboards zu finden, so dass man beim Schlachten eines solchen günstig an einen Temperatursensor kommen kann. Eine Beispiel Schaltplan mit einem ATmega8 findet man [http://www.ucblog.de/2010/09/mikrocontroller-thermometer-schaltplan/ hier]

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* I²C-Bus Ausgang
* billiger als DS1621 (Reichelt 1,45 €; RS 3V: 3,75€; 5V: 2,72€)
* Auflösung +-0,5°C

Nachteile:
* nur im SMD-Gehäuse erhältlich
* relativ ungenau (+-2°C), kann man jedoch kalibrieren / kompensieren

Kompatible Typen:
* AD7415ART
* DS7505S+

=== LM76 ===

Der LM76 ähnlich dem LM75, bietet aber eine 8-fach höhere Auflösung und eine Genauigkeit von 0.5 bzw. 1°C.

Vorteile:
* höhere Auflösung
* höhere Genauigkeit

Nachteil:
* schwerer zu beschaffen

=== TMP175 / TMP75 ===

Ähnelt dem LM75 stark! Temperatursensor von Texas Instruments.

=== DS18S20 / DS18B20 ===

Der DS18S20 (Nachfolger des DS1820) und DS18B20 sind scheinbar Temperatursensoren und A/D-Wandler in einem. Wenn man genauer hinschaut, stellt man fest, dass es sich um direktwandelnde Sensoren handelt. Die Temperatur wird ohne Umweg über eine analoge Zwischengröße (Spannung oder Strom) in ein digitales Signal überführt.

Die Datenkommunikation erfolgt über ein 1-Wire-Interface, wodurch man am [[Mikrocontroller]] mit nur einem einzigen I/O-Pin auskommen kann. Außerdem beherrschen sie die parasitäre Stromversorgung, d.h., man braucht für Daten und Stromversorgung zusammen nur zwei Leitungen.

Beim DS18B20 sind Auflösungen von 9, 10, 11 und 12 Bits konfigurierbar. Je kleiner die Auflösung, desto kürzer ist die Messzeit. Der DS18S20 hat eine feste Auflösung von 12 Bits, wobei die unteren 3 Bits aufwändiger auszuwerten sind als beim DS18B20. Der DS18S20 ist als Ersatz für den DS1820 gedacht. Der Hersteller empfiehlt den DS18B20 für Neuentwicklungen.

Vorteile:
* bereits kalibriert
* Genauigkeit +-0,5°C
* 1-Wire-Ausgang

Nachteil:
* relativ teuer: Reichelt: 2,50€ / CSD: 1,85€ / Conrad 5,08€

Links:
* [http://pdfserv.maxim-ic.com/en/ds/DS18S20.pdf Datenblatt DS18S20]
* [http://pdfserv.maxim-ic.com/en/ds/DS18B20.pdf Datenblatt DS18B20]
* [http://www.maxim-ic.com/app-notes/index.mvp/id/4377 Vergleich DS18B20 <-> DS18S20]
* [http://www.mikrocontroller.net/topic/6505 Code zur Ansteuerung (ASM ATTiny12)]
* [http://www.mikrocontroller.net/topic/14792 Code zur Ansteuerung (AVR-GCC)]
* [http://gandalf.arubi.uni-kl.de/avr_projects/tempsensor/ Code zur Ansteuerung mit CRC-Prüfung (AVR-GCC)]
* [http://chaokhun.kmitl.ac.th/~kswichit/avrthermo/avrthermo.html LED-Thermometer mit AT90S2313 (C)]
* [http://www.mikrocontroller.net/forum/read-4-248219.html Webserver zur Ansteuerung von bis zu 63 Bausteinen]
* [http://www.teslabs.com/openplayer/docs/docs/other/ds18b20_pre1.pdf PDF Anleitung zur Beschaltung und Programmierung (C)]
*[http://www.digitemp.com/building.shtml Anleitung Sensorfühleraufbau (DigiTemp)]
* http://www.mikrocontroller.net/topic/14792
* http://www.mikrocontroller.net/topic/232156 (Timing der parasitären Versorgung)

=== DS1822 ===

Ähnlich wie DS18S20, aber weniger genau (+-2°) und in großen Stückzahlen billiger. Wegen der geringeren Verbreitung kommt der Preisvorteil aber bei Einzelstücken nicht beim Kunden an. So kostet er bei Reichelt mit 3,50€ mehr als der DS18S20.

=== DS1921 / DS1922 ===

Sind wie die DS1821 1-wire-Sensoren mit zusätzlicher Logging-Funktion.
Im iButton-Gehäuse befindet sich eine Lithium-Zelle, eine RTC, CMOS-RAM und der Temp-Sensor. Nach umfangreicher Progammierung startet der Button seine Mission (Aufzeichnung des Temperaturverlaufs).
Gibt es auch mit zusätzlicher Feuchtemessung (DS1923).

=== TSic ===

Die TSic Sensoren werden baugleich von 3 Herstellern angeboten:
* ZMD ([http://www.zmd.biz/temp.php?group=temp&content=products Homepage]) ([http://tarr.uspto.gov/servlet/tarr?regser=serial&entry=78673282 Trademark])
* IST AG ([http://www.ist-ag.com/eh/ist-ag/de/home.nsf/contentview/8F5D32432CAC53C2C1257405003C2433 Homepage])
* Hygrosens ([http://www.hygrosens.de/english/shop/list.html?tx_ttproducts_pi1%5Bcat%5D=11&cHash=dcd89b823b Homepage])

Die TSic Sensoren ([http://www.zmd.biz/pdf/ZMD%20TSic%20Data%20Sheet%20V3%207.pdf Datenblatt]) geben ihre Temperaturmessdaten automatisch in einem festen Intervall aus. Daher muss der Host nur warten bis die nächsten Messdaten rausgeschickt werden. Die TSic Sensoren die es im freien Handel gibt, geben ihre Messdaten alle 100ms (10Hz) aus.
Zur Übertragung wird das [http://www.zmd.biz/pdf/IST_TSic_ZACwire_V2.3%20Digital%20Output_17-Oct-06.pdf ZACwire] Protokoll benutzt. Es handelt sich um eine einfach zwei Byte Übertragung per Manchester-Code. Diese zwei Byte repräsentieren den digital gewandelten Temperaturwert. Im Gegensatz zu Sensoren wie den DS18xxx von Dallas muss dieser Wert aber erst auf einen dezimalen Wert umgerechnet werden.
Die Sensoren kommen mit 3 Pins aus (VCC, GND, Dout).

Vorteile:
* Bereits kalibriert
* Verschiedene Genauigkeiten lieferbar
* Sehr einfaches Kommunikationsprotokoll
* Geringer Stromverbrauch
* Hochgenau: bis zu +/- 0.1°C (TSic 50x)

Nachteil:
* Recht teuer (Reichelt: 4,70€ für den TSic206)
* Nur ein Sensor an einem I/O nutzbar (Kein Bussystem)

Achtung!
Die TSic Sensoren gibt es auch als Version mit analog Ausgang. Bei der Typenbezeichnung gibt die 3. Stelle an ob es sich um die analog- oder Digitalversion handelt (1 = analog, 6 = digital).
Der TSic201 ist also analog, wärend der TSic206 ein digitaler ist.

Links:
* [http://www.mikrocontroller.net/topic/45573#347765 Ansatz zum Empfang der Daten]
* [http://www.mikrocontroller.net/topic/225554# Beispiel mit Strobe ohne Interrupt]
* [http://ethersex.de/index.php/Zacwire Fertige Ansteuerung durch AVR in Ethersex]
* [http://www.zmd.biz/temp.php?group=temp&content=products Herstellerseite mit Datenblättern und FAQ]
* [http://www.mikrocontroller.net/topic/82087 Diskussion mit Beispielcode (MSP430, AVR, PIC) blockierend]
* [http://www.mikrocontroller.net/topic/144424#1367539 C++ Interrupt]
* [http://www.mikrocontroller.net/topic/88847 noch mehr C, problematisch Interrupt]
* [http://www.mikrocontroller.net/topic/151791#1426974 C für ATmega8]
* [http://www.mikrocontroller.net/topic/159149#1510455 auch problematisch]
* [http://www.sinc.sunysb.edu/Stu/maman/ESE_381.htm Projekt mit tsic sensor, evtl. code]
* [http://www.mikrocontroller.net/topic/188462#1837622 fertiger Code zum Einlesen des Zacwire-Protokolls für PIC in ASM]
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=55103 RN: Bascom]
* [http://www.mikrocontroller.net/search?query=tsic* Suche in den Foren]
* [http://www.avr-projekte.de/tinyclock.htm TSIC206 Thermometer mit Uhr und Kalender. Komplette Bauanleitung mit ASM Quellcode für AT-Tiny2313]

=== SHT1x/SHT7x ===

Der SHT1x/SHT7x (SHT10, SHT11, SHT15, STH71, SHT75) sind kombinierte Temperatur- und Feuchtesensoren von [http://www.sensirion.com Sensirion]. Sie unterscheiden sich in Bauform und Genauigkeit.

Vorteile:
* digitale Schnittstelle mit einfacher [[I²C]]-''ähnlicher'' Ansteuerung
* keine Kalibrierung notwendig
* Beispielcode (C, MC51) auf der Sensirion-Seite verfügbar (relativ leicht portierbar)
* interne Heizelemente (Funktionsprüfung, "rauhe" Umgebung)
* Spannungsmonitor ("Battery fail")
* sehr hohe Genauigkeit

Nachteile:
* kann nicht am [[I²C]] Bus betrieben werden, theoretisch gleiche Clockleitung möglich, fixe Adresse
* relativ teuer (Farnell 18,60€)(SHT11 bei CSD 14€)

[http://www.sensirion.com/en/01_humidity_sensors/00_humidity_sensors.htm Übersicht] der Temperatur- /Feutchtigkeitssensoren von Sensirion.

=== SHT21 ===

[http://www.sensirion.com Sensirion] bietet auch den SHT21 Feuchtigkeits- und Temperatursensor an, welcher wesentlich genauer ist.

Vorteile:
* I2C digital, PWM and SDM/analog Volt Ausgabe
* Maximal 5 Messungen/s @ 14bit
* Temperaturbereich von -40 – +125°C
* Feuchtigkeit mit einer Genauigkeit von +-3%RH

Nachteile:
* teuer (Farnell 23 €, Segor 29 €)
* nur als SMD-Package

Application Notes und Datenblätter findet man [http://www.sensirion.com/en/01_humidity_sensors/10_Overview.htm hier].

=== ADT7310 ===

Der ADT7310 von [http://www.analog.com/en/sensors/digital-temperature-sensors/adt7310/products/product.html Analog Devices] besitzt eine Auflösung von 16 Bit und eine Genauigkeit von ±0.5°C im Bereich von −40°C bis +105°C.

Vorteile:
* Ansteuerung per [[SPI]] (für [[I2C]] siehe [http://www.analog.com/en/sensors/digital-temperature-sensors/adt7410/products/product.html ADT7410])
* keine Kalibrierung notwendig
* hohe [[Auflösung und Genauigkeit]]
* programmierbarer [[Interrupt]]ausgang für Unter- und Übertemperatur
* relativ günstig (ca. 3€ bei Digi-Key, Stand 12/2011)

Nachteile:
* TBD

[[Category:Sensorik]]

Temperatursensor

2011-11-28T19:07:16Z

Mthomas: /* Thermoelement */

Will man mit einem [[Mikrocontroller]] Temperaturen messen, dann braucht man
* einen [[Sensor]], der die Temperatur z. B. in eine Spannung oder einen Strom umsetzt
* einen [[ADC | AD-Wandler]], der das Signal digitalisiert. Der kann auf dem Sensor oder dem Mikrocontroller integriert sein.

Temperatursensoren gibt es nun in allen möglichen Varianten. Vom temperaturabhängigen [[Widerstand]] bis zum fertig abgeglichenen All-in-one-Bauteil mit digitalem Ausgang. Wie bei allen Sensoren sollte man auch hier genau hinschauen und [[Auflösung und Genauigkeit]] unterscheiden.

== Analoge Temperatursensoren ==

=== PT100 ===

Unter einem PT100 versteht man einen Platinwiderstand, der bei 0°C einen Widerstand von 100Ω hat.
Platinwiderstände sind temperaturabhängige Widerstände mit hoher Wiederholgenauigkeit und Konstanz[http://de.wikipedia.org/wiki/Konstante]. Wegen der relativ geringen Widerstandsänderung von nur ca. 0,4Ω pro Grad ist etwas mehr Schaltungsaufwand erforderlich als bei anderen Sensoren. Genauere Formeln zur Temperaturbestimmung gibt es u.a. bei der [http://de.wikipedia.org/wiki/Pt100 Wikipedia]. Ein Schaltplan findet sich bei der [http://www.heise.de/ct/artikel/Sensibelchen-289608.html c't].

Die Sensoren gibt es auch mit anderen Widerstandswerten, z. B. mit 1000Ω und heißen dann entsprechend PT1000.

Vorteil:
* genormt
* großer Meßbereich
* hohe Linearität
* hohe Wiederholgenauigkeit
* einfach austauschbar

Nachteil:
* relativ teuer (bei segor.de ab 3,80€)
* brauchen aufwendigere Auswerteschaltung

Links:
* [http://www.heise.de/ct/04/22/236/ c't-Artikel: Mikrocontroller-Programmierung: Timer, Sensoren und Drehgeber (mit PT100 Schaltung)]
* [http://pdfserv.maxim-ic.com/en/an/AN3450.pdf Maxim AN3450 Positive Analog Feedback Compensates PT100 Transducer]

=== NTC/PTC ===

NTC und PTC sind temperaturabhängige Widerstände.

* NTC (engl. '''N'''egative '''T'''emperature '''C'''oefficient, Heißleiter), hat bei hohen Temperaturen seinen niedrigsten Widerstand, z. B. Silizium
* PTC (engl. '''P'''ositive '''T'''emperature '''C'''oefficient, Kaltleiter), hat bei niedrigen Temperaturen seinen geringsten Widerstand, z. B. Glühlampe

Um den Widerstandswert zu messen schaltet man sie mit einem normalen Widerstand oder einer [[Konstantstromquelle]] in Reihe zu einem [[Spannungsteiler]] und misst den Spannungsabfall. Eine Beispielschaltung findet sich [http://www.mathar.com/msp_thermo1.html hier].

Vorteil:
* billig (z.B. [http://www.reichelt.de/?ARTICLE=9594 KTY81-110] bei Reichelt ~0,60€)

Nachteil:
* müssen für höhere Genauigkeiten abgeglichen werden
* brauchen A/D-Wandler
* sind nichtlinear

Beispiele:
* KTY10-5
* KTY13-6
* KTY81-121
* KTY81-122

Links:
* [http://www.sprut.de/electronic/temeratur/temp.htm Temperaturabhängige Stromquelle und NTC/PTC inclusive Linearisierung]
*[http://www.umnicom.de/Elektronik/Mikrokontroller/Atmel/AtFan/AtFan.html#2.2.2 Berechnung des Linearisierungswiderstandes für gewünschten Temperaturbereich] der fällt sonst immer vom Himmel
* [http://www.mikrocontroller.net/topic/208587#2065880 KTY 10-5 Formelprobleme]
* [http://www.mikrocontroller.net/topic/225563 Codesammlung: Beispiel mit 0,5°C Auflösung]

=== LMx35 ===

Eine IC-Familie, die pro Kelvin Temperaturänderung ihre Ausgangsspannung um 10 mV ändert. Die ICs gibt es in verschiedenen Genauigkeiten und Temperaturbereichen mit den Bezeichnungen LM135(A), LM235(A) und LM335(A). Der günstigste ist der LM335 mit einem Temperaturbereich von −40 … +100°C.
In verschiedenen Bauformen erhältlich. Beispielschaltungen finden sich im [http://www.national.com/ds.cgi/LM/LM135.pdf Datenblatt] und [http://www.suessbrich.info/elek/elektherm1.html hier]

Vorteile:
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)
* relativ billig (LM335 bei Reichelt ab 0,50 €)

Nachteile:
* benötigt A/D-Wandler
* bei längerer Anschlussleitung störanfällig

=== LM334 ===

Ein IC ähnlich dem LM335 mit dem Unterschied, dass der durch das IC fließende Strom proportional von der Temperatur abhängt. Mit einer einfachen Schaltung aus nur zwei Widerständen kann man dann den Strom in einer Weise wandeln, dass pro Kelvin eine Spannungsänderung von 10mV ausgegeben wird. Da die Strom-Spannungswandlung auf der Platine (und damit nahe am AD-Wandler) stattfindet und die Übertragung des Messwerts durch einen Strom stattfindet, sind Störungen durch Netzbrumm etc. viel geringer als beim LM335

Vorteile:

* relativ billig ([http://www.reichelt.de/?ARTICLE=10468 Reichelt 0,54 €])

Nachteile:
* benötigt A/D-Wandler
* Bereich 0°C-70°C

Ähnliche ICs:
* AD592 (Ausgangsstrom 1µA pro Kelvin, absolute Temperatur) [http://www.reichelt.de/?ARTICLE=3825 Reichelt: 3,75 €], Conrad 174912 8,50 €

=== SMT160-30 ===

Ist ein Zwischending zwischen Digital und Analog. Sein Ausgangssignal ist ein digitales PWM-Signal, zu dessen Messung man am besten den Input-Capture-Eingang eines Mikrocontrollers verwendet. Man kann ihn also wie einen analogen Sensor nur indirekt auslesen, anstatt über einen AD-Wandler hier über einen Timer.

Vorteile:
* Digitales PWM-Signal ist unempfindlich gegen Störeinflüsse
* gibt es in SO8, TO18, TO92 und TO220, gut befestigbar, z.B am Kühlkörper
* linear
* kein Abgleich nötig

Nachteile (viele):
* benötigt Timer
* jittert extrem, genaue Messungen nur über Mittelung / Filterung möglich
* nicht nur das PWM-Verhältnis, sondern auf die Frequenz ist temp-abhängig (1-4kHz)
* teuer (Farnell 10,90€ +16%, Conrad 9,xx€ , www.hy-line.de ??).
* TO92 Gehäuse ist günstiger, dafür weniger genau

Links:
* http://www.hy-line.de/co/sensor-tec/hersteller/smartec/smt-160-30/index.html

=== Thermoelement ===

Ein Thermoelement besteht im einfachsten Fall aus zwei ungleichen Metallendrähten, die an einem Punkt miteinander verbunden sind und bei dem die Verbindungsstelle einer anderen Temperatur ausgesetzt ist als die offenen Enden der Drähte. An den offenen Enden der Drähten entsteht eine Spannung (Thermospannung). Dieser Effekt wurde 1821 von Thomas Seebeck entdeckt ([http://de.wikipedia.org/wiki/Seebeck-Effekt Seebeck-Effekt] bei Wikipedia). Eine weitere Anwendung ist der thermoelektrische Generator ("Thermogenerator").

Vorteil:
* über einen sehr weiten Temperaturbereich einsetzbar

Nachteil:
* die sehr geringen Temperaturspannungen im Mikrovoltbereich benötigen eine sehr gute Auswertelektronik (guter Analogteil + AD-Wandler).

Links:
* [http://digital.ni.com/worldwide/germany.nsf/web/all/7A4F02BAEFEC22AC802567F6003E0D6E Temperaturmessung mit Thermoelementen] - Eine Einführung von David Potter (deutsche Überarbeitung: G.Sinkovic) (inkl. Erläuterung der Kaltstellenkompensation)
* [http://www.sensorwell.at/fileadmin/templates/images/data_sheets/temperatur_messtechnik.pdf Warum Thermoelemente Relativtemperaturen messen! oder Was ist eine Kaltstelle?] - Technische Information von www.sensorwell.at (PDF, ca. 600kB)

== Digitale Temperatursensoren ==

=== DS1621 ===

Der DS1621 ist Temperatursensor und A/D-Wandler in einem. Er gibt seine Daten per [[I²C]]-[[Bus]] aus. Ein Schaltplan für einen elektronischen Thermometer mit diesem IC findet sich [http://www.myplace.nu/avr/thermo/ hier].

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* da I²C ein Bus ist, kann man mehrere DS1621 und andere I²C-Bausteine zusammen anschließen und braucht dafür trotzdem nur zwei I/O-Ports.
* Messbereich -55°C to +125°C
* Genauigkeit +-0,5°C
* Auflösung besser 0,01°C, wenn man die beiden Zählerregister (Count-Remain und Count-per-C) auswertet

Nachteile:
* teuer (Segor 5,80€; RS 3,95€; Conrad 5,22€)
* obwohl die meisten Register [[Speicher#NVRAM | nichtflüchtig]] sind, kann man ihn nicht als Stand-Alone-Thermostat einsetzen, da er erst nach einem Start-Conversion-Befehl zu messen beginnt.

Nachfolger:
* DS1631, DS1631A (Auto-Start-> Stand-Alone-Thermostat), DS1731
* weitere Stand-Alone-Thermostaten: DS1821, DS1629

=== LM75 ===

Der LM75 ist so ähnlich wie der DS1621, allerdings nur in SMD erhältlich und nicht so genau. Er ist aber öfters mal auf PC-Mainboards zu finden, so dass man beim Schlachten eines solchen günstig an einen Temperatursensor kommen kann. Eine Beispiel Schaltplan mit einem ATmega8 findet man [http://www.ucblog.de/2010/09/mikrocontroller-thermometer-schaltplan/ hier]

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* I²C-Bus Ausgang
* billiger als DS1621 (Reichelt 1,45 €; RS 3V: 3,75€; 5V: 2,72€)
* Auflösung +-0,5°C

Nachteile:
* nur im SMD-Gehäuse erhältlich
* relativ ungenau (+-2°C), kann man jedoch kalibrieren / kompensieren

Kompatible Typen:
* AD7415ART
* DS7505S+

=== LM76 ===

Der LM76 ähnlich dem LM75, bietet aber eine 8-fach höhere Auflösung und eine Genauigkeit von 0.5 bzw. 1°C.

Vorteile:
* höhere Auflösung
* höhere Genauigkeit

Nachteil:
* schwerer zu beschaffen

=== TMP175 / TMP75 ===

Ähnelt dem LM75 stark! Temperatursensor von Texas Instruments.

=== DS18S20 / DS18B20 ===

Der DS18S20 (Nachfolger des DS1820) und DS18B20 sind scheinbar Temperatursensoren und A/D-Wandler in einem. Wenn man genauer hinschaut, stellt man fest, dass es sich um direktwandelnde Sensoren handelt. Die Temperatur wird ohne Umweg über eine analoge Zwischengröße (Spannung oder Strom) in ein digitales Signal überführt.

Die Datenkommunikation erfolgt über ein 1-Wire-Interface, wodurch man am [[Mikrocontroller]] mit nur einem einzigen I/O-Pin auskommen kann. Außerdem beherrschen sie die parasitäre Stromversorgung, d.h., man braucht für Daten und Stromversorgung zusammen nur zwei Leitungen.

Beim DS18B20 sind Auflösungen von 9, 10, 11 und 12 Bits konfigurierbar. Je kleiner die Auflösung, desto kürzer ist die Messzeit. Der DS18S20 hat eine feste Auflösung von 12 Bits, wobei die unteren 3 Bits aufwändiger auszuwerten sind als beim DS18B20. Der DS18S20 ist als Ersatz für den DS1820 gedacht. Der Hersteller empfiehlt den DS18B20 für Neuentwicklungen.

Vorteile:
* bereits kalibriert
* Genauigkeit +-0,5°C
* 1-Wire-Ausgang

Nachteil:
* relativ teuer: Reichelt: 2,50€ / CSD: 1,85€ / Conrad 5,08€

Links:
* [http://pdfserv.maxim-ic.com/en/ds/DS18S20.pdf Datenblatt DS18S20]
* [http://pdfserv.maxim-ic.com/en/ds/DS18B20.pdf Datenblatt DS18B20]
* [http://www.maxim-ic.com/app-notes/index.mvp/id/4377 Vergleich DS18B20 <-> DS18S20]
* [http://www.mikrocontroller.net/topic/6505 Code zur Ansteuerung (ASM ATTiny12)]
* [http://www.mikrocontroller.net/topic/14792 Code zur Ansteuerung (AVR-GCC)]
* [http://gandalf.arubi.uni-kl.de/avr_projects/tempsensor/ Code zur Ansteuerung mit CRC-Prüfung (AVR-GCC)]
* [http://chaokhun.kmitl.ac.th/~kswichit/avrthermo/avrthermo.html LED-Thermometer mit AT90S2313 (C)]
* [http://www.mikrocontroller.net/forum/read-4-248219.html Webserver zur Ansteuerung von bis zu 63 Bausteinen]
* [http://www.teslabs.com/openplayer/docs/docs/other/ds18b20_pre1.pdf PDF Anleitung zur Beschaltung und Programmierung (C)]
*[http://www.digitemp.com/building.shtml Anleitung Sensorfühleraufbau (DigiTemp)]
* http://www.mikrocontroller.net/topic/14792
* http://www.mikrocontroller.net/topic/232156 (Timing der parasitären Versorgung)

=== DS1822 ===

Ähnlich wie DS18S20, aber weniger genau (+-2°) und in großen Stückzahlen billiger. Wegen der geringeren Verbreitung kommt der Preisvorteil aber bei Einzelstücken nicht beim Kunden an. So kostet er bei Reichelt mit 3,50€ mehr als der DS18S20.

=== DS1921 / DS1922 ===

Sind wie die DS1821 1-wire-Sensoren mit zusätzlicher Logging-Funktion.
Im iButton-Gehäuse befindet sich eine Lithium-Zelle, eine RTC, CMOS-RAM und der Temp-Sensor. Nach umfangreicher Progammierung startet der Button seine Mission (Aufzeichnung des Temperaturverlaufs).
Gibt es auch mit zusätzlicher Feuchtemessung (DS1923).

=== TSic ===

Die TSic Sensoren werden baugleich von 3 Herstellern angeboten:
* ZMD ([http://www.zmd.biz/temp.php?group=temp&content=products Homepage]) ([http://tarr.uspto.gov/servlet/tarr?regser=serial&entry=78673282 Trademark])
* IST AG ([http://www.ist-ag.com/eh/ist-ag/de/home.nsf/contentview/8F5D32432CAC53C2C1257405003C2433 Homepage])
* Hygrosens ([http://www.hygrosens.de/english/shop/list.html?tx_ttproducts_pi1%5Bcat%5D=11&cHash=dcd89b823b Homepage])

Die TSic Sensoren ([http://www.zmd.biz/pdf/ZMD%20TSic%20Data%20Sheet%20V3%207.pdf Datenblatt]) geben ihre Temperaturmessdaten automatisch in einem festen Intervall aus. Daher muss der Host nur warten bis die nächsten Messdaten rausgeschickt werden. Die TSic Sensoren die es im freien Handel gibt, geben ihre Messdaten alle 100ms (10Hz) aus.
Zur Übertragung wird das [http://www.zmd.biz/pdf/IST_TSic_ZACwire_V2.3%20Digital%20Output_17-Oct-06.pdf ZACwire] Protokoll benutzt. Es handelt sich um eine einfach zwei Byte Übertragung per Manchester-Code. Diese zwei Byte repräsentieren den digital gewandelten Temperaturwert. Im Gegensatz zu Sensoren wie den DS18xxx von Dallas muss dieser Wert aber erst auf einen dezimalen Wert umgerechnet werden.
Die Sensoren kommen mit 3 Pins aus (VCC, GND, Dout).

Vorteile:
* Bereits kalibriert
* Verschiedene Genauigkeiten lieferbar
* Sehr einfaches Kommunikationsprotokoll
* Geringer Stromverbrauch
* Hochgenau: bis zu +/- 0.1°C (TSic 50x)

Nachteil:
* Recht teuer (Reichelt: 4,70€ für den TSic206)
* Nur ein Sensor an einem I/O nutzbar (Kein Bussystem)

Achtung!
Die TSic Sensoren gibt es auch als Version mit analog Ausgang. Bei der Typenbezeichnung gibt die 3. Stelle an ob es sich um die analog- oder Digitalversion handelt (1 = analog, 6 = digital).
Der TSic201 ist also analog, wärend der TSic206 ein digitaler ist.

Links:
* [http://www.mikrocontroller.net/topic/45573#347765 Ansatz zum Empfang der Daten]
* [http://www.mikrocontroller.net/topic/225554# Beispiel mit Strobe ohne Interrupt]
* [http://ethersex.de/index.php/Zacwire Fertige Ansteuerung durch AVR in Ethersex]
* [http://www.zmd.biz/temp.php?group=temp&content=products Herstellerseite mit Datenblättern und FAQ]
* [http://www.mikrocontroller.net/topic/82087 Diskussion mit Beispielcode (MSP430, AVR, PIC) blockierend]
* [http://www.mikrocontroller.net/topic/144424#1367539 C++ Interrupt]
* [http://www.mikrocontroller.net/topic/88847 noch mehr C, problematisch Interrupt]
* [http://www.mikrocontroller.net/topic/151791#1426974 C für ATmega8]
* [http://www.mikrocontroller.net/topic/159149#1510455 auch problematisch]
* [http://www.sinc.sunysb.edu/Stu/maman/ESE_381.htm Projekt mit tsic sensor, evtl. code]
* [http://www.mikrocontroller.net/topic/188462#1837622 fertiger Code zum Einlesen des Zacwire-Protokolls für PIC in ASM]
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=55103 RN: Bascom]
* [http://www.mikrocontroller.net/search?query=tsic* Suche in den Foren]
* [http://www.avr-projekte.de/tinyclock.htm TSIC206 Thermometer mit Uhr und Kalender. Komplette Bauanleitung mit ASM Quellcode für AT-Tiny2313]

=== SHT1x/SHT7x ===

Der SHT1x/SHT7x (SHT10, SHT11, SHT15, STH71, SHT75) sind kombinierte Temperatur- und Feuchtesensoren von [http://www.sensirion.com Sensirion]. Sie unterscheiden sich in Bauform und Genauigkeit.

Vorteile:
* digitale Schnittstelle mit einfacher [[I²C]]-''ähnlicher'' Ansteuerung
* keine Kalibrierung notwendig
* Beispielcode (C, MC51) auf der Sensirion-Seite verfügbar (relativ leicht portierbar)
* interne Heizelemente (Funktionsprüfung, "rauhe" Umgebung)
* Spannungsmonitor ("Battery fail")
* sehr hohe Genauigkeit

Nachteile:
* kann nicht am [[I²C]] Bus betrieben werden, theoretisch gleiche Clockleitung möglich, fixe Adresse
* relativ teuer (Farnell 18,60€)(SHT11 bei CSD 14€)

[http://www.sensirion.com/en/01_humidity_sensors/00_humidity_sensors.htm Übersicht] der Temperatur- /Feutchtigkeitssensoren von Sensirion.

=== SHT21 ===

[http://www.sensirion.com Sensirion] bietet auch den SHT21 Feuchtigkeits- und Temperatursensor an, welcher wesentlich genauer ist.

Vorteile:
* I2C digital, PWM and SDM/analog Volt Ausgabe
* Maximal 5 Messungen/s @ 14bit
* Temperaturbereich von -40 – +125°C
* Feuchtigkeit mit einer Genauigkeit von +-3%RH

Nachteile:
* teuer (Farnell 23 €, Segor 29 €)
* nur als SMD-Package

Application Notes und Datenblätter findet man [http://www.sensirion.com/en/01_humidity_sensors/10_Overview.htm hier].

=== ADT7310 ===

Der ADT7310 von [http://www.analog.com/en/sensors/digital-temperature-sensors/adt7310/products/product.html Analog Devices] besitzt eine Auflösung von 16 Bit und eine Genauigkeit von ±0.5°C im Bereich von −40°C bis +105°C.

Vorteile:
* Ansteuerung per [[SPI]] (für [[I2C]] siehe [http://www.analog.com/en/sensors/digital-temperature-sensors/adt7410/products/product.html ADT7410])
* keine Kalibrierung notwendig
* hohe [[Auflösung und Genauigkeit]]
* programmierbarer [[Interrupt]]ausgang für Unter- und Übertemperatur

Nachteile:
* zur Zeit noch schlecht erhältlich (z.B. bei Digikey für 3,15$)

[[Category:Sensorik]]

MOSFET-Übersicht

2011-11-22T20:27:53Z

Mthomas: /* Weblinks */

Im Forum wird immer wieder gefragt, welchen Mosfet-Transistor man für ein Projekt einsetzen sollte. Und wo man die herbekommt. Deshalb soll hier eine Übersicht mit gängigen Mosfet-Transistoren entstehen, wo auch die Bezugsquellen angegeben sind. Bezugsquellen sollten nach Möglichkeit solche sein, die auch für den privaten Bastler in Frage kommen.

Der Thread zum Thema: http://www.mikrocontroller.net/topic/41588

siehe auch : [[Transistor-Übersicht]] - [[Dioden-Übersicht]] - [[Standardbauelemente]]

== P-Kanal MOSFET==

{| {{Tabelle}} border="1" class="sortable" id="pkanalmosfets"
|- style="background-color:#eeeeee"
! Bezeichnung
! Package
! Hersteller
! UGS/V
! UDS/V
! ID/A
! P/W
! RDS,on/mOhm
! Bemerkung
! Lieferant
! Einzelpreis
|-
| [http://www.mikrocontroller.net/part/BS250 BS250]
| TO-92/SOT-23
| Siliconix
| 4,0
| 60
| 0,12
| 0,35
| 10000
| -
|[[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Buerklin|Bü]]
| 0,32 €
|-
| [http://www.mikrocontroller.net/part/BSH205 BSH205]
| SOT23
| Phi
| 1,0
| 12
| 0,75
| 0,4
| 500
| kleine Gatekapazität (3.8nC)
| [[Elektronikversender#csd-electronics|csd]] (a.A.)
| 0,30 €
|-
| [http://www.mikrocontroller.net/part/SI2301 SI2301]
| SOT23
| Vishay
| 1,5
| 20
| 2,0
| 0,7
| 150
| kleine Gatekapazität (typ 4.5nC)
| [[Elektronikversender#farnell|farnell]]
| 0,30 €
|-
| [http://www.mikrocontroller.net/part/IRLML6302 IRLML6302PBF]
| SOT23
| IRF
| 1,5
| 20
| 0,75
| 0,54
| 600
| ähnlich BSH205
| [[Elektronikversender#csd-electronics|csd]],[[Elektronikversender#Buerklin|Bü]]
| 0,18 €
|-
| [http://www.mikrocontroller.net/part/BSS83 BSS83P]
| SOT23
| Inf
| 3,0
| 60
| 0,33
| 0,35
| 2000
| -
| [[Elektronikversender#Reichelt|Rei]]
| 0,11 €
|-
| [http://www.mikrocontroller.net/part/BSS84 BSS84]
| SOT23
| Fairchild,NXP
| 2,0
| 50
| 0,13
| 0,35
| 10000
| -
| [[Elektronikversender#Farnell|Fa]]
| 0,28 €
|-
| [http://www.mikrocontroller.net/part/BSS83 BSS83]
| TO-97, SOT23
| Phi
| 3,0
| 50
| 0,13
| 0,35
| 10000
| -
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 0,07 €
|-
| [http://www.mikrocontroller.net/part/BSS110 BSS110]
| TO-97, SOT23
| Phi
| 3,0
| 50
| 0,17
| 0,35
| 10000
| -
| ?
| ?
|-
| [http://www.mikrocontroller.net/part/PMV65XP PMV65XP]
| SOT23
| Phi
| 1,4
| 20
| 3,9
| ?
| 76
| grosser ID für Bauform
| [[Elektronikversender#Spoerle|Spo]], [[Elektronikversender#RS_Components|RS]]
| 0,10 € (3000er-Rolle)
|-
| [http://www.mikrocontroller.net/part/IRF4905S IRF4905S]
| D2Pack
| irf
| 4,0
| 55
| 64
| 3,8
| 20
| -
| [[Elektronikversender#Conrad|Con]]
| 2,60 €
|-
| [http://www.mikrocontroller.net/part/IRF4905 IRF4905]
| TO-220AB
| irf
| 4,0
| 55
| 74
| 3,8
| 20
| -
|[[Elektronikversender#Reichelt|Rei]]
| 0,93 €
|-
| [http://www.mikrocontroller.net/part/IRF5210S IRF5210S]
| D2Pack
| irf
| 10,0
| 100
| 40
| ?
| 60
| -
|[[Elektronikversender#Reichelt|Rei]]
| 1,25 €
|-
| [http://www.mikrocontroller.net/part/IRF7104 IRF7104]
| SO-8
| irf
| 3,0
| 20
| 2,3
| 2,0
| 250
| 2 FETs im Gehäuse
|[[Elektronikversender#Reichelt|Rei]]
| 0,36 €
|-
| [http://www.mikrocontroller.net/part/IRF7205 IRF7205]
| SO-8
| irf
| 3,0
| 30
| 4,6
| 2,5
| 70
| ?
|[[Elektronikversender#Reichelt|Rei]]
| 0,34 €
|-
| [http://www.mikrocontroller.net/part/FDC604P FDC604P]
| SuperSOT-6
| Fairchild
| 1,5
| 20
| 5,5
| 0,8-1,6
| 33
| -
| [[Elektronikversender#csd-electronics|csd]] (a.A.)
| 0,70 €
|-
| [http://www.mikrocontroller.net/part/NDS0610 NDS0610]
| SOT-23
| Fairchild
| 1,8
| 60
| 0,12
| 0,36
| 10000
| -
| [[Elektronikversender#csd-electronics|csd]]
| 0,07 €
|-
| [http://www.mikrocontroller.net/part/IRF5305 IRF5305]
| TO-220AB
| irf
| 3,0
| 55
| 31
| 110
| 60
| -
|[[Elektronikversender#Reichelt|Rei]]
| 0,59 €
|-
| [http://www.mikrocontroller.net/part/NDS352P NDS352P]
| SOT23
| Fairchild
| 4,5
| 20
| 0,85
| 0,5
| 500
| -
| [[Elektronikversender#Conrad|Con]]
| 0,76 €
|-
| [http://crio.mib.infn.it/wig/electronics/Componenti/Siemens/MOS%20Transistor/BSP171.pdf BSP171]
| SOT-223
| Siemens
| 1,4
| 60
| 1,7
| 1,8
| 350
| -
|[[Elektronikversender#Reichelt|Rei]]
| 0,51 €
|-
| [http://www.mikrocontroller.net/part/IRFD9014 IRFD9014]
| HEXDIP/DIP4
| irf
| 2,0
| 60
| 1,1
| 1,3
| 500
| -
| [[Elektronikversender#Conrad|Con]]
| 0,65 €
|-
| [http://www.mikrocontroller.net/part/IRFD9024 IRFD9024]
| HEXDIP/DIP4
| irf
| 2,0
| 60
| 1,6
| 1,3
| 280
| -
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 0,50 €
|-
| [http://www.mikrocontroller.net/part/IRF7416 IRF7416]
| SO-8
| irf
| 1,0
| 30
| 10
| 2,5
| 20
| -
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 0,60 €
|-
| [http://www.mikrocontroller.net/part/SUP75P03 SUP75P03-007]
| TO-220AB
| VISHAY
| 3,0
| 30
| 75
| 187
| 7
| -
| nessel-elektronik.de
| 2,30 €
|-
| IRF4905
| TO-220AB
| irf
| 3,0
| 55
| 74
| 200
| 20
| -
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 1,20 €
|-
| IRF7220
| SO-8
| irf
| 0,6
| 14
| 11
| 2,5
| 8,2
| spezifiziert ab 2,5V Vgs, Qg=84nC
| [[Elektronikversender#Conrad|Con]], [[Elektronikversender#Reichelt|Rei]]
| 0,58 €
|-
| IRF7410
| SO-8
| irf
| 0,4...0,9
| 12
| 16
| 2,5
| 7
| spezifiziert ab 1,8V Vgs, Qg=91nC
| [[Elektronikversender#Conrad|Con]]
| 2,03 €
|}

(Tabelle mit Click im Kopfbereich sortierbar; a.A. = Auf Anfrage)

== N-Kanal MOSFET==

{| {{Tabelle}} class="sortable" id="nkanalmosfets"
|- style="background-color:#eeeeee"
! Bezeichnung
! Package
! Hersteller
! UGS(th)/V
! UDS/V
! ID/A
! P/W
! RDS,on/mOhm
! Bemerkung
! Lieferant
! Preis/EUR
|-
| IRFP 4310Z
| TO-247AC
| irf
| 2-4
| 100
| 120
| 280
| 4.8
|
| [[Elektronikversender#Reichelt|Rei]]
| 1.80
|-
| [http://www.mikrocontroller.net/part/IRFP450 IRFP450]
| TO-247
| irf
| 3
| 500
| 14
| 190
| 400
|
| [[Elektronikversender#Reichelt|Rei]]
| 1.20
|-
| [http://www.mikrocontroller.net/part/IRF530 IRF530]
| TO-220
| irf
| 2.9
| 100
| 16
| 94
| 160
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.44
|-
| [http://www.mikrocontroller.net/part/IRL3103 IRL3103]
| TO-220AB
| irf
| 1.0
| 30
| 64
| 94
| 12
| Qg=33nC (!)
| [[Elektronikversender#Segor-electronics|Seg]]
| 0.95
|-
| [http://www.mikrocontroller.net/part/IRF730A IRF730A]
| TO-220AB
| irf
| 2.0
| 400
| 5.5
| 74
| 1000
| Qg=22nC (!)
| [[Elektronikversender#Reichelt|Rei]]
| 0.54
|-
| [http://www.mikrocontroller.net/part/IRFP064 IRFP064]
| TO-247AC
| irf
| 2.0
| 60
| 70
| 300
| 9
| Qg=190 nC
| [[Elektronikversender#Reichelt|Rei]]
| 1.65
|-
| [http://www.mikrocontroller.net/part/IRF3205 IRF3205]
| TO-220AB
| irf
| 2.0
| 55
| 110
| 200
| 8
|
| [[Elektronikversender#Reichelt|Rei]]
| 1.10
|-
| [http://www.mikrocontroller.net/part/IRL3803 IRL3803]
| TO-220AB
| irf
| 1.0
| 30
| 140
| 200
| 6
| Qg=140nC
| [[Elektronikversender#Reichelt|Rei]]
| 0.96
|-
| [http://www.mikrocontroller.net/part/IRF540 IRF540]
| TO-220AB
| irf
| 3
| 100
| 28
| 150
| 77
|
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Kessler|Kes]]
| 0.52
|-
| [http://www.mikrocontroller.net/part/IRF7401 IRF7401]
| SO-8
| irf
| 2.7
| 20
| 8.7
| 2.0
| 22
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.565
|-
| [http://www.mikrocontroller.net/part/IRF7403 IRF7403]
| SO-8
| irf
| 4.85
| 30
| 8.5
| 2.5
| 22
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.42
|-
| [http://www.mikrocontroller.net/part/IRF7413 IRF7413]
| SO-8
| irf
| 3.0
| 30
| 13.0
| 2.5
| 11
|
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Kessler|Kes]]
| 0.41
|-
| [http://www.mikrocontroller.net/part/BUZ11 BUZ11]
| TO-220
| ST
| 5.0
| 50
| 33.0
| 90.0
| 30
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.50
|-
| [http://www.mikrocontroller.net/part/BS170 BS170]
| TO-92
| gs
| 2.0
| 60
| 0.3
| 0.83
| 5000
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.13
|-
| [http://www.mikrocontroller.net/part/BSN20 BSN20]
| SOT-23
| gs
| 1.8
| 50
| 0.18
| 0.35
| 6000
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.092
|-
| [http://www.mikrocontroller.net/part/BSS138 BSS138]
| SOT-23
| div
| 0.8-1.6
| 50
| 0.22
| 0.36
| 2000
| Rds=1,4-3,6Ω je nach Hersteller
| [[Elektronikversender#Reichelt|Rei]]
| 0.06
|-
| [http://www.mikrocontroller.net/part/BSS123 BSS123]
| SOT-23
| div
| 0.8-1.6
| 100
| 0.17
| 0.36
| 10000 @ 4,5V
| [http://www.fairchildsemi.com/ds/BS/BSS123.pdf Datenblatt]
| [[Elektronikversender#Reichelt|Rei]]
| 0.06
|-
| [http://www.mikrocontroller.net/part/IRFP2907 IRFP2907]
| TO-247AC
| irf
| 4.0
| 75
| 209
| 470
| 4.5
|
| [[Elektronikversender#Reichelt|Rei]]
| 4.70
|-
| [http://www.mikrocontroller.net/part/2N7000 2N7000]
| TO-92
| ON
| 3.0
| 60
| 0.2
| 0.35
| 5000
|
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Kessler|Kes]]
| 0.13
|-
| [http://www.mikrocontroller.net/part/BS107 BS107]
| TO-92
| ON, Phi
| 3.0
| 200
| 0.25
| 0.35
| 6400/14000
| -
| [[Elektronikversender#Reichelt|Rei]]
| 0.18
|-
| [http://www.mikrocontroller.net/part/BS108 BS108]
| TO-92
| ON, Phi
| 2.0
| 200
| 0.25
| 0.35
| 8000
| -
| [[Elektronikversender#Reichelt|Rei]]
| 0.14
|-
| [http://www.mikrocontroller.net/part/BUK100 BUK100]
| TO-220
| Phi
| 3.0
| 50
| 13.5
| 40
| 125
| Overload-Protection, ESD-Protection
| [[Elektronikversender#Reichelt|Rei]]
| 1.40
|-
| [http://www.mikrocontroller.net/part/IRL3705N IRL3705N]
| TO-220AB
| irf
| 2.0
| 55
| 89
| 170
| 10
| Qg=98nC
| [[Elektronikversender#Reichelt|Rei]]
| 1.20
|-
| [http://www.mikrocontroller.net/part/BUZ72 BUZ72A]
| TO-220
| Infineon
| 4.0
| 100
| 9.0
| 40
| 250
| -
| [[Elektronikversender#Reichelt|Rei]]
| 0.45
|-
| [http://www.mikrocontroller.net/part/IRLZ34N IRLZ34N]
| TO-220
| irf
| 2.5
| 55
| 30
| 68
| 35
| Logic-Level
| [[Elektronikversender#Reichelt|Rei]]
| 0.42
|-
| [http://www.mikrocontroller.net/part/IRLML2502 IRLML2502]
| SOT23
| irf
| 1.2
| 20
| 4.2
| 1
| 45
| Logic-Level
| [[Elektronikversender#csd-electronics|csd]] [[Elektronikversender#Reichelt|Rei (neu)]]
| 0.21
|-
| [http://www.mikrocontroller.net/part/IRF1404 IRF1404]
| TO-220AB
| irf
| 4.0
| 40
| 202
| 333
| 4
| -
| [[Elektronikversender#Reichelt|Rei]]
| 1.65
|-
| [http://www.mikrocontroller.net/part/IRL1004 IRL1004]
| TO-220
| irf
| 2.7
| 40
| 130
| 200
| 6.5
| -
| [[Elektronikversender#Reichelt|Rei]]
| 1.25
|-
| [http://www.mikrocontroller.net/part/IRL530 IRL530]
| TO220, D2Pack
| irf
| 2
| 100
| 15.0
| 88
| 160
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.51
|-
| [http://www.mikrocontroller.net/part/IRF830 IRF830]
| TO220AB
| irf
| 2.0-4.5
| 500
| 5.0
| 74
| 1400
|
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Kessler|Kes]]
| 0.57
|-
| [http://www.mikrocontroller.net/part/IRF840 IRF840]
| TO220AB
| irf
| 2.0-4.0
| 500
| 8.0
| 125
| 850
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.57
|-
| [http://www.mikrocontroller.net/part/FDC645N FDC645N]
| SuperSOT-6
| Fairchild
| 1.5
| 30
| 5.5
| 0.8/1.6
| 30
| -
| [[Elektronikversender#csd-electronics|csd]] (a.A.), Far
| 0.7
|-
| [http://www.mikrocontroller.net/part/BSP297 BSP297]
| SOT-223
| Siemens/Infineon
| 0.8-2.4
| 200
| 0.65
| 1.8
| 6000
| 200V UDS, SMT und LL (seltene Kombi)
| [[Elektronikversender#Farnell|Far]], [[Elektronikversender#Schuricht|Schu]], [[Elektronikversender#RS_Components|RS]]
| 0.56
|-
| [http://www.mikrocontroller.net/part/IRF7455 IRF7455]
| SO-8
| irf
| 4.5
| 30
| 15
| 2.5
| 7.5
|
| [[Elektronikversender#Kessler|Kes]]
| 1.04
|-
| [http://www.mikrocontroller.net/part/SI4442DY SI4442DY]
| SO-8
| vis
| 2.5
| 30
| 22
| 2.5
| 5/4.5V
|
| [[Elektronikversender#Kessler|Kes]]
| 1.64
|-
| [http://www.mikrocontroller.net/part/IRLU2905 IRLU2905]
| TO251, DPack
| irf
| 2.0
| 55
| 42
| 110
| 27
| Logic-Level
| [[Elektronikversender#Reichelt|Rei]]
| 0.72
|-
| [http://www.mikrocontroller.net/part/IRFD014 IRFD014]
| HEXDIP/DIP4
| irf
| 2.0-4.0
| 60
| 1.7
| 1.3
| 200
|
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 0.52
|-
| [http://www.mikrocontroller.net/part/IRFD024 IRFD024]
| HEXDIP/DIP4
| irf
| 2.0-4.0
| 60
| 2.5
| 1.3
| 100
|
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 0.54
|-
| [http://www.mikrocontroller.net/part/IRLD024 IRLD024]
| HEXDIP/DIP4
| irf
| 1.0-2.0
| 60
| 2.5
| 1.3
| 100
| Logic-Level
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 0.47
|-
| [http://www.mikrocontroller.net/part/IRLU3717 IRLU3717]
| I-Pak
| irf
| 2.0
| 20
| 120
| 1.5/89
| 4
| Qg=21nC
| [[Elektronikversender#Conrad|Con]],[[Elektronikversender#Reichelt|Rei]]
| 0.86
|-
| [http://www.mikrocontroller.net/part/IRFP3703 IRFP3703]
| TO-247AC
| irf
| 4.0
| 30
| 210
| 230
| 2.8
|
| [[Elektronikversender#Conrad|Con]]
| 5.08
|-
| [http://www.mikrocontroller.net/part/IRF3710 IRF3710]
| TO-220AB
| irf
| 5
| 100
| 57
| 200
| 23
|
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Conrad|Con]]
| 0.83
|-
| [http://www.mikrocontroller.net/part/IRLR7843 IRLR7843]
| D-Pack
| irf
| 2.3
| 30
| 164
| 140
| 3.3
| Qg: 34nC, Rds_on bei GS=4.5V: max. 4.0mOhm
| [http://www.flymotec.de/]
| 0.70
|-
| [http://www.mikrocontroller.net/part/IRF1010N IRF1010N]
| TO-220AB
| irf
| 4
| 55
| 85
| 180
| 11
|
| [[Elektronikversender#Reichelt|Rei]]
| 0.83
|-
| [http://www.mikrocontroller.net/part/IRF1010Z IRF1010Z]
| TO-220AB
| irf
| 4
| 55
| 75
| 140
| 7.5
|
| [[Elektronikversender#Reichelt|Rei]]
| 1.20
|-
| [http://www.mikrocontroller.net/part/IRLIZ44N IRLIZ44N]
| TO-220-Fullpak
| irf
| 1.0 - 2.0
| 55
| 30
| 45
| 25
| Logic Level
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Conrad|Con]]
| 0.80
|-
| [http://www.mikrocontroller.net/part/IRLU024N IRLU024N]
| TO-251AA
| irf
| 1.0 - 2.0
| 55
| 17
| 45
| 80
| Logic Level, Qg=15 nC (!)
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Conrad|Con]]
| 0.40
|-
| IRFZ48N
| TO-220AB
| irf
| 3
| 55
| 64
| 130
| 14
|
| [[Elektronikversender#Reichelt|Rei]],[[Elektronikversender#Conrad|Con]]
| 0.60
|-
| [http://www.irf.com/product-info/datasheets/data/irl2505.pdf IRL2505]
| TO-220AB
| irf
| 2,5
| 55
| 104
|
| 8
|
|
|
|-
| IRF7607
|
| irf
|
|
|
|
|
|
|
|
|-
| IRF3708
|
| irf
|
|
|
|
|
|
|
|

|}

(Tabelle mit Click im Kopfbereich sortierbar, a.A.=Auf Anfrage)

== N-Kanal J-FET==

{| {{Tabelle}} border="1" class="sortable" id="fetpaare"
|- style="background-color:#eeeeee"
! Bezeichnung
! Package
! Hersteller
! UGS(co)/V
! UDS/V
! ID(max)/mA
! Lieferant
! Einzelpreis
|-
| [http://www.mikrocontroller.net/part/BF245 BF245A]
| TO-92
| diverse
| -2,2
| 30
| 6,5
| [[Elektronikversender#Reichelt|Rei]]
| 0,15 €
|-
| [http://www.mikrocontroller.net/part/BF245 BF245B]
| TO-92
| diverse
| -3,8
| 30
| 15
| [[Elektronikversender#Reichelt|Rei]]
| 0,15 €
|-
| [http://www.mikrocontroller.net/part/BF245 BF245C]
| TO-92
| diverse
| -7,5
| 30
| 25
| [[Elektronikversender#Reichelt|Rei]]
| 0,15 €
|-
| [http://www.mikrocontroller.net/part/BF246 BF246A]
| TO-92
| diverse
| -4
| 25
| 80
| [[Elektronikversender#Reichelt|Rei]]
| 0,15 €
|-
| [http://www.mikrocontroller.net/part/BF246 BF246B]
| TO-92
| diverse
| -7
| 25
| 140
| [[Elektronikversender#Reichelt|Rei]]
| 0,17 €
|-
| [http://www.mikrocontroller.net/part/BF246 BF246C]
| TO-92
| diverse
| -12
| 25
| 250
| ??
| ??
|-
| [http://www.mikrocontroller.net/part/BF511 BF511]
| SOT-23
| diverse
| -1,5
| 20
| 7
| [[Elektronikversender#Reichelt|Rei]]
| 0,36 €
|-
| [http://www.mikrocontroller.net/part/BFR30 BFR30]
| SOT-23
| diverse
| -4
| 25
| 10
| ?
| ?
|-
| [http://www.mikrocontroller.net/part/BFR31 BFR31]
| SOT-23
| diverse
| -2
| 25
| 5
| ?
| ?
|-
| [http://www.mikrocontroller.net/part/MMBF4416 MMBF4416]
| SOT-23
| Fairchild
| -5,5
| 15
| 5
| [[Elektronikversender#Conrad|Con]]
| 0,52 €
|}

(Tabelle mit Click im Kopfbereich sortierbar)

== FET-Paare ==

{| {{Tabelle}} border="1" class="sortable" id="fetpaare"
|- style="background-color:#eeeeee"
! Bezeichnung
! Package
! Hersteller
! UGS/V
! UDS/V
! ID/A
! P/W
! RDSon/mOhm
! Bemerkung
! Lieferant
! Einzelpreis
|-
| [http://www.mikrocontroller.net/part/IRF7389 IRF7389]
| SO-8
| IRF
| 3,0
| 30
| 7,3/-5,3
| 2,0
| 29/58
| P+N
| [[Elektronikversender#Reichelt|Rei]]
| 0,56 €
|-
| [http://www.mikrocontroller.net/part/IRF7501 IRF7501]
| micro8
| IRF
| 2,7
| 20
| 2,4
| ?
| 135 @4,5VGS
| 2*N
| [[Elektronikversender#Kessler|Kessler]], [[Elektronikversender#Conrad|Con]]
| 1,64 €
|-
| [http://www.mikrocontroller.net/part/IRF7506 IRF7506]
| micro8
| IRF
| 4,5
| 30
| 1,7
| ?
| 270 @10VGS
| 2*P
| [[Elektronikversender#Kessler|Kessler]], [[Elektronikversender#Conrad|Con]]
| 0,56 €
|-
| [http://www.mikrocontroller.net/part/IRF7103 IRF7103]
| SO-8
| IRF
| 4,5
| 50
| 2,3
| 2
| 130 @10VGS
| 2*N
|[[Elektronikversender#Reichelt|Rei]], [[Elektronikversender#Conrad|Con]]
| 0,32 €
|-
| [http://www.mikrocontroller.net/part/IRF7104 IRF7104]
| SO-8
| IRF
| 4,5
| 20
| 2,3
| 2
| 250 @10VGS
| 2*P
|[[Elektronikversender#Reichelt|Rei]]
| 0,32 €
|-
| [http://www.mikrocontroller.net/part/IRF7316 IRF7316]
| SO-8
| IRF
| 4,5
| 30
| 4,9
| ?
| 58 @10VGS
| 2*P
|[[Elektronikversender#Reichelt|Rei]]
| 0,49 €
|-
| [http://www.mikrocontroller.net/part/IRF7313 IRF7313]
| SO-8
| IRF
| 4,5
| 30
| 6,5
| ?
| 46 @4.5VGS
| 2*N
| [[Elektronikversender#Kessler|Kessler]], [[Elektronikversender#Conrad|Con]]
| 0,66 €
|-
| [http://www.mikrocontroller.net/part/FDD8424H FDD8424H]
| Dual DPAK4L
| Fairchild
|
| 40
| 9/-6,5
| 3
| 24/54 @10VGS 30/70 @4,5VGS
| P+N
| [[Elektronikversender#Digi-Key|Digi-Key]]
| 0,73 €
|-
| [http://www.mikrocontroller.net/part/SUD50NP04-94 SUD50NP04-94]
| TO252-4L DPAK4L
| Vishay
| 2
| 40
| 8
| 8?
| 41/53 @10VGS 45/72 @4,5VGS
| P+N
| [[Elektronikversender#Farnell|Farnell]]
| 0,56 €
|-
| [http://www.mikrocontroller.net/part/IRFI4024H-117P IRFI4024H-117P]
| TO-220-5
| IRF
| 2
| 55
| 11
| 14
| 50 @10VGS
| 2*N
| [[Elektronikversender#Reichelt|Reichelt]]
| 2,10 €
|}

(Tabelle mit Click im Kopfbereich sortierbar)

== MOSFET-Treiber ==
* Detaillierte [[Treiber]]-Dimensionierung
{| {{Tabelle}} border="1" class="sortable" id="fettreiber"
|- style="background-color:#eeeeee"
! Bezeichnung
! Bemerkung
! Lieferant / Datenblatt
! Einzelpreis
|-
| [http://www.mikrocontroller.net/part/IR2101 IR2101]
| High & Low-Side Driver, 130/270mA, 600V, 3,3V Logikeingang, DIL8/SO8
| [[Elektronikversender#Conrad|Con]]
| 2,30 €
|-
| [http://www.mikrocontroller.net/part/IR2104 IR2104]
| Half Bridge Driver, 130/270mA, 600V, 3,3V Logikeingang, DIL8/SO8
| [[Elektronikversender#Conrad|Con]]
| 2,00 €
|-
| [http://www.mikrocontroller.net/part/IR2110 IR2110]
| High & Low-Side Driver, 2A, 500V, 3,3V Logikeingang, DIL14/SO16
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 1,55 €
|-
| [http://www.mikrocontroller.net/part/IR2111 IR2111]
| Half Bridge Driver 200/430mA, 600V, 10-20V CMOS Eingang, DIL8/SO8, maximale Kriechwege
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 1,10 €
|-
| [http://www.mikrocontroller.net/part/IR2112 IR2112]
| High & Low-Side Driver, 200/420mA, 600V, 3,3V Logikeingang, DIL14/SO16
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 1,45 €
|-
| [http://www.mikrocontroller.net/part/IR2113 IR2113]
| High & Low-Side Driver, 2A, 600V, 3,3V Logikeingang, DIL14/SO16
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 1,85 €
|-
| [http://www.mikrocontroller.net/part/IR2117 IR2117]
| Single High Side Driver, 200/420mA, 600V, 10-20V CMOS Eingang, DIL8/SO8, maximale Kriechwege
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 1,20 €
|-
| [http://www.mikrocontroller.net/part/IR2121 IR2121]
| Low Side Driver, 1A/2A, 2,5V Logikeingang, Strombegrenzung, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 2,15 €
|-
| [http://www.mikrocontroller.net/part/IR2125 IR2125]
| Single Channel High Side Driver, 1A/2A, 500V, 2,5V Logikeingang, Strombegrenzung, maximale Kriechwege, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 4,20 €
|-
| [http://www.mikrocontroller.net/part/IR2127 IR2127]
| Single Channel High Side Driver, 200/420mA, 3,3V Logikeingang, DIL8/SO8, maximale Kriechwege, Fehlerausgang
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 2,40 €
|-
| [http://www.mikrocontroller.net/part/IR2130 IR2130]
| 3-Phase Bridge Driver, 200/420mA, 600V, 2,5V Logikeingang, DIL28/SO28
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 2,50 €
|-
| [http://www.mikrocontroller.net/part/IR2151 IR2151]
| Self Oscillating Half Bridge Driver, 100/210mA, 600V, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 2,50 €
|-
| [http://www.mikrocontroller.net/part/IR2153 IR2153]
| Self Oscillating Half Bridge Driver, 100/210mA, 600V, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 1,20 €
|-
| [http://www.mikrocontroller.net/part/IR2155 IR2155]
| Self Oscillating Half Bridge Driver, 210/420mA, 600V, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 3,50 €
|-
| [http://www.mikrocontroller.net/part/IR2181 IR2181]
| High & Low-Side Driver, 1.4A/1.8A, 600V, 3,3V Logikeingang, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 2,10 €
|-
| [http://www.mikrocontroller.net/part/IR2183 IR2183]
| Half Bridge Driver, 1.4A/1.8A, 600V, 3,3V Logikeingang, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]]
| 4,00 €
|-
| [http://www.mikrocontroller.net/part/IR2184 IR2184]
| Half Bridge Driver, 1.4A/1.8A, 600V, 3,3V Logikeingang, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]] [[Elektronikversender#Conrad|Con]]
| 3,20 €
|-
| [http://www.mikrocontroller.net/part/IR2136 IR2136]
| 3 Phase Driver, 120/250mA, 600V, 3,3V Logikeingang, DIP28/SOIC28,
| [[Elektronikversender#Conrad|Con]]
| 1,80 €
|-
| [http://www.mikrocontroller.net/part/ICL7667 ICL7667]
| Dual Power MOSFET Driver, 4.5-15V, 7Ω, 3,3V Logikeingang, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]]
| 2,00 €
|-
| [http://www.mikrocontroller.net/part/HIP4081A HIP4081A]
| Full Bridge Driver, 80V 2,5A, DIP20/SOIC20
| [[Elektronikversender#Farnell|Far]]
| 8,00 €
|-
| [http://www.mikrocontroller.net/part/HIP4082 HIP4082]
| Full Bridge Driver, 80V, 1,2A DIP16/SOIC16
| [[Elektronikversender#Farnell|Far]] [[Elektronikversender#Farnell|Far]]
| 6,20 €
|-
| [http://www.mikrocontroller.net/part/HIP4083 HIP4083]
| 3 Phase High side N-channel MOSFET driver, 80V, 0,3A, DIP16/SOIC16
| [[Elektronikversender#Farnell|Far]]
| 4,80 €

|-
| [http://www.mikrocontroller.net/part/HIP4086 HIP4086]
| 3 Phase Driver, 80V, 0.5A, DIP24/SOIC24
| [[Elektronikversender#Farnell|Far]]
| 8,00 €
|-
| [http://www.mikrocontroller.net/part/TC4451 TC4451/TC4452]
| High Speed MOSFET Driver, 12A peak, 2,5A DC, 4,5-18V, DIL8/SO8
| [[Elektronikversender#Farnell|Far]]
| 3,00 €
|-
| [http://www.mikrocontroller.net/part/LM5104 LM5104]
| Half Bridge Driver, 1,6/1,8A, 100V, 2,5V Logikeingang, SO8/LLP10
| [[Elektronikversender#RS_Components|RS]]
| 3,20 €
|-
| [http://www.mikrocontroller.net/part/MCP1407 MCP1407-E/P]
| High Speed MOSFET Driver, 6A peak, 1,3A DC, 4,5-18V, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]]
| 0,95 €
|-
| [http://www.mikrocontroller.net/part/MAX626 MAX626]
| Dual Power MOSFET drivers, inverting, 4,5-18 V, DIL8/SO8
| [[Elektronikversender#Reichelt|Rei]]
| 3,40 €
|}

== Anmerkungen ==
* UGS - minimale Gatespannung, bei welcher der MOSFET zu leiten anfängt (100µA..1mA, nicht genormt). Zur vollständigen Durchschaltung bei maximalem Strom braucht es höhere Spannungen.
* Logic Level - FET schaltet bei niedrigen Gatespannungen von typisch 4,5V (z. B. CMOS Logikpegel) hinreichend durch. Normale MOSFETs brauchen hierfür typisch 10V.
* UGS(co) - Gate Source Cut Off Spannung, bei welcher der Drainstrom ID eines JFETs praktisch Null ist. Die Messbedingung ist jedoch nicht genormt (0,5nA..200µA).
* N-Kanal MOSFETs mit niedrigem RDS,On sind technologisch einfacher herzustellen als P-Kanal MOSFETs. Deshalb gibt es bei P-Kanal keine so große Auswahl und oft werden Schaltungen angestrebt, in denen ausschließlich N-Kanal MOSFETs verwendet werden. Es gibt spezielle Treiberbausteine, die über eine Ladungspumpe für entsprechend hohe Gatespannung auch für die High-Side N-Fets sorgen ("Bootstrap Circuits", siehe Artikel [[Treiber]]).
* Bei der Dimensionierung ist zu beachten, dass die Stromangabe im allgemeinen für 25°C gilt. Geht man davon aus, dass der MOSFET mit maximal zulässigem Strom betrieben wird und mit passend dimensioniertem [[Kühlkörper]] ausgestattet ist, so beträgt die Sperrschichttemperatur bis zu 150°C, folglich gilt z. B. für den IRF540 nicht mehr 28A, sondern nur noch ca. 12-15A.
* Restströme sind auch stark von der Temperatur abhängig. Bei höherer Temperatur nehmen die Restströme exponentiell zu. So können bei 100°C durchaus 100 µA zwischen Source und Drain auch im gesperrten Zustand fließen. Bei 25°C ist dieser Reststrom meist bei 1µA spezifiziert. Real sind es meist weniger.
* Die Gate-Charge-Werte (s. Datenblatt) bestimmen, wie schnell das Gate beim Schalten umgeladen werden kann. Auch wenn MOSFETs stromlos den durchgeschalteten Zustand halten können, braucht man während des Umschaltvorganges einen Strom, der das Gate umlädt (ähnlich wie ein Kondensator). Je höher dieser Strom, um so schneller ist der Umschaltvorgang und um so geringer die Verlustleistung während dieser Phase. Leistungs-MOSFETs können bei höheren Frequenzen (>1KHz) oft nur mit höheren Gateströmen von 0,1A-2A sinnvoll geschaltet werden. Man kann das Gate also nicht direkt an einen Digitalpin anschließen. Man braucht einen [[MOSFET-Übersicht#MOSFET-Treiber | MOSFET-Treiber]]. Manche MOSFETs haben eine sehr geringe Total Gate Charge (z. B. 4-10nC). Diese können in gewissen Grenzen recht gut direkt an digitalen [[Ausgangsstufen Logik-ICs | Logikausgängen]] betrieben werden. Zur Abschätzung kann man sich merken: Wenn man das Gate eines MOSFETs mit einer Eingangskapazität von 1nF (~10nC) in 100ns auf 10V aufladen will, braucht man dazu 100mA.

== Lieferantenübersicht ==
* [[Elektronikversender#Reichelt|Rei]]<nowiki>chelt</nowiki>
* [[Elektronikversender#Conrad|Con]]<nowiki>rad</nowiki>
* [[Elektronikversender#Kessler|Kes]]<nowiki>sler</nowiki>
* [[Elektronikversender#csd-electronics|csd]]<nowiki>-electronics</nowiki>
* [[Elektronikversender#Farnell|Far]]<nowiki>nell</nowiki> (nur gewerbliche Kunden oder Studenten)
* HBE-Shop (FARNELL-Fachhändler, auch als nichtgewerblicher Kunde)
* [[Elektronikversender#Schuricht|Schu]]<nowiki>richt</nowiki>
* [[Elektronikversender#RS_Components|RS]]
* [[Elektronikversender#Spoerle|Spo]]<nowiki>erle</nowiki>

== Herstellerübersicht ==
* [irf] [http://www.irf.com International Rectifier]
* [Siliconix] [http://www.vishay.com/company/brands/siliconix/ Vishay Siliconix]

== Links ==
* [[FET]]
* [[IGBT]]
* [[Treiber]]
* [[H-Brücken Übersicht]]

== Weblinks ==
* [http://www.sprut.de/electronic/switch/nkanal/nkanal.html N-Kanal MOSFET leicht erklärt bei sprut.de]
* [http://www.sprut.de/electronic/switch/pkanal/pkanal.html P-Kanal MOSFET leicht erklärt bei sprut.de]
* [http://elektronik-kompendium.de/sites/bau/0510161.htm MOSFET im ElKo]
* [http://elektronik-kompendium.de/public/schaerer/battoff.htm Abschaltverzögerung beim ElKo]
* [http://elektronik-kompendium.de/sites/bau/0207011.htm FET beim ElKo]
* [http://de.wikipedia.org/wiki/Mosfet MOSFET bei Wikipedia]


== Parametrische Suche beim Hersteller ==
* [http://www.infineon.com/cms/de/product/channel.html?channel=db3a304319c6f18c011a14e5341b25f1 Infineon]
* [http://www.nxp.com/#/ps/ps=%5Bi%3D48014%5D%7Cpp%3D%5Bt%3Dpfp%2Ci%3D48014%5D NXP standard Mosfets]
* [http://www.onsemi.com/PowerSolutions/parametrics.do?id=809&lctn=home ONsemi]
* [http://www.diodes.com/zetex/?ztx=3.0/3-3-1@tcatid~7 Diodes (vormals Zetex)]
* [http://www.irf.com/product-info/hexfet/ IRF]
* [http://www.vishay.com/mosfets/ Vishay]

[[Category:Bauteile]]

Kategorie:Boards

2011-11-19T16:03:37Z

Mthomas: Schützte „Kategorie:Boards“ ([edit=autoconfirmed] (bis 19. Februar 2012, 16:03 Uhr (UTC)) [move=autoconfirmed] (bis 19. Februar 2012, 16:03 Uhr (UTC)))

[[Kategorie:!Hauptkategorie]]

Kategorie:ARM-Boards

2011-11-02T20:38:24Z

Mthomas: Schützte „Kategorie:ARM-Boards“: scheinbare Vorarbeit zum Spammen ([edit=autoconfirmed] (unbeschränkt) [move=autoconfirmed] (unbeschränkt))

[[Kategorie:ARM|B]]
[[Kategorie:Boards]]

MP2103-Stick: Ein Mini-Mikrocontroller-Board mit USB und bis zu 4MB Datenspeicher

2011-11-01T08:17:30Z

Mthomas: Schützte „MP2103-Stick: Ein Mini-Mikrocontroller-Board mit USB und bis zu 4MB Datenspeicher“: Weblink-Spam ([edit=autoconfirmed] (unbeschränkt) [move=autoconfirmed] (unbeschränkt))

''von Mario Pieschel''

== Einleitung ==

Der MP2103-Stick ist ein kleines Arm7-Mikrocontroller-Board, welches sehr einfach und damit sehr billig gehalten wurde. Jeglicher Schnickschnack wurde weggelassen und möglichst viele Pins des Mikrocontrollers zu den beiden Steckverbindern geführt. Als Mikrocontroller kommt der LPC2103 von NXP zum Einsatz. Viele Mikrocontroller-Anwendungen sind als Stand-Alone-Anwendungen konzipiert – der MP2103-Stick nicht!!! Er soll mehr als Interface-Baustein für den PC gesehen werden.
Anwendungsbereiche sehe ich überall dort, wo irgendetwas mit dem PC elektrisch verbunden werden soll, was sich sonst nicht mit diesem über die herkömmlichen PC-Schnittstellen verbinden lässt. Da der LPC2103 über eine mannigfaltige Peripherie verfügt (digitale Ein/Ausgänge, ADC, Timer, I2C, SPI/SSP, PWM, RTC), sehe ich fast keine Grenzen in seinem Einsatzspektrum. Überall wo der PC steuern, regeln und/oder messen soll, könnte der MP2103-Stick zum Einsatz kommen. Die Daten feuern vom und zum PC mit einer Datenübertragungsgeschwindigkeit von fast bis zu 1 Megabit pro Sekunde! Für eventuelle Kalibrierdaten oder andere individuelle Daten für das zu betreibende Gerät steht ein bis zu 4 Megabyte großer Datenspeicher zur Verfügung. Für den MP2103-Stick wird kein spezielles Programmiergerät benötigt – er wird einfach an einen USB-Anschluss eines PCs angeschlossen und das war’s. An ein bestimmtes Betriebssystem des Ziel-PCs ist man ebenfalls nicht gebunden, da für den eingesetzten USB-Baustein (FT232) Treiber für alle gängigen Betriebssysteme vom Hersteller FTDI-Chip angeboten werden.

[http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher LINK: MP-Stick mit ARM Cortex-M3 (STM32F103CBT6)]

[[Bild:MP2103Stick.jpg]]

== Funktionsmodell des MP2103-Stick ==

[[Bild:MP2103 Model.PNG]]

[http://www.nxp.com/acrobat_download/datasheets/LPC2101_02_03_2.pdf LINK: Datasheet vom LPC2103]

[http://www.nxp.com/acrobat/usermanuals/UM10161_2.pdf LINK: Usermanual vom LPC2103]

[http://www.nxp.com/acrobat/erratasheets/ES_LPC2103_4.pdf LINK: Erratasheet vom LPC2103]

[http://atmel.com/dyn/products/devices.asp?family_id=616#1802 LINK: Datasheet und Anwendung vom AT45DBxxx]

== Schaltungsbeschreibung ==

Die Schaltung des MP2103-Sticks gliedert sich in fünf Funktionsgruppen.

1. Dem Mikrocontroller LPC2103 von NXP (IC3) mit seiner Grundbeschaltung (dem so genannten Hühnerfutter), den beiden Quarzen (Q2: 14,7456MHz und Q1: 32,768kHz), dem Anschluss für eine Real-Time-Clock-Batterie und den beiden Anschlussleisten CON1 und CON2 für externe Elektronik.

2. Dem USB-IC FT232RL (IC4) mit Hühnerfutter und der USB-Buchse.

3. Dem 4 Megabyte großen Datenspeicher AT45DB321 von Atmel (IC2) mit Hühnerfutter.
Es sind auch die kleineren Varianten z. B. AT45DB161 (2MB) und AT45DB081 (1MB) möglich. Der AT45DB642 (8MB) hat leider ein anderes Gehäuse - Das Löten geht dann nur mit etwas Geschick.

4. Der Reset-Automatik für Normalbetrieb und Programmiermodus mit Signal-LED (die Schaltung oben rechts).

5. And last but not least die Mikrocontroller-Core-Spannungsversorgungsschaltung von 1,8 Volt mit LM317D oben links.

== Schaltplan ==

[[Media:MP2103stick_schematic.GIF|LINK: Schaltplan gesamt]]

[[Bild:MP2103stick_schematic_LPC2103.GIF]]

[[Bild:MP2103stick_schematic_USB.GIF]]

[[Bild:MP2103stick_schematic_AT45DBxxx.GIF]]

[[Bild:MP2103stick_schematic_RESET.GIF]]

[[Bild:MP2103stick_schematic_LM317.GIF]]

Der Mikrocontroller benötigt vier Betriebsspannungen:

– VDD1.8, für den Core an Pin 5 (1,8 Volt)

– VDD3.3, für dessen Peripherie an Pin 17 und 40 (3,3 Volt)

– VDDA, für die analogen Komponenten an Pin 42 (3,3 Volt)

– VBAT, für die Real Time Clock an Pin 4 (3,3 Volt)

Die Core-Spannung wird mit dem LM317 erzeugt und mit den Widerständen R1 und R2 fest eingestellt. Die 3,3 Volt werden im FT232RL erzeugt. VDDA wird über den Widerstand R10 von VDD3.3 bezogen. VBAT wird über die Diode D2 von VDD3.3 oder von einer externen Backup-Batterie versorgt. Die Kondensatoren an den Versorgungsspannungen dienen der Entkopplung von Störsignalen und damit dem sicheren Betrieb des LPC2103. R1! und R2! mit je Null Ohm in den beiden Spannungsversorgungsleitungen VDD1.8 und VDD3.3 dienen dem Schutz des Mikrocontrollers bei Inbetriebnahme des MP2103-Sticks. Sie sollten erst ganz zum Schluss eingelötet werden – erst wenn alle Spannungen überprüft und OK sind.
Dem Mikrocontroller wird mit dem Quarz Q2 (14,7456 MHz Grundton) sozusagen das Leben eingehaucht. Er erzeugt den Takt für den LPC2103. Durch den Multiplier in diesem kann das System mit bis zu 4 x 14,7456MHz = 58,9824MHz betrieben werden. Der krumme Wert von 14,7456MHz ist einzig und allein für die Kommunikation zum PC über die UART0 und USB von Nöten. Q1 ist ein normaler Uhren-Quarz mit 32KHz für die interne Echtzeituhr.
An CON1 und CON2 gehen fast alle Pins des Mikrocontrollers. CON1 und CON2 sind im Raster 2,54mm auf der Leiterplatte angeordnet, so dass eine Lochraster-Leiterplatte auf den Stick gesteckt werden kann.
Die Kommunikation mit einem PC/Labtop erfolgt mit dem seriellen Port UART0 des LPC2103 (Pin 13 und 14) über den USB-zu-seriell-Umsetzer FT232RL (IC4). Dort gehen die beiden Signale (Leitungen) RXD und TXD gekreuzt an die Pins 1 und 5. Die beiden Handshake-Signale RTS und DTR sind über den Dip-Schalter S2 mit der Reset-Automatik oben rechts verbunden. Die beiden Datenleitungen USBDM (Pin 16) und USBDP (Pin 15) sind direkt mit der USB-B-Buchse (Pin 2 und 3) verbunden. VDD (5 Volt) kommt von Pin 1 der USB-B-Buchse über L1 (Entstörung) und geht an Pin 20 von IC4 und an Pin 16 von CON2 zur Außenwelt. Aus Sicherheitsgründen sind die 3.3 Volt nicht nach außen geführt. Wenn man auf seiner externen Schaltung 3,3 Volt benötigt, kann man dieses sehr einfach mit einem weiteren LM317 mit angepassten Widerständen bewerkstelligen.
Die Reset-Automatik oben rechts im Schaltplan sorgt bei geöffnetem Dip-Schalter S2 und nicht gestecktem Jumper auf BSL_HAND (BSL = Bootstrap Loader: Urlader) für ein ordnungsgemäßes Starten des Mikrocontrollers im Normalbetrieb. LED1 kann dann in einem Programm als Signallampe benutzt werden. Wird der Jumper BSL_HAND gesteckt geht der Mikrocontroller sofort nach einem Reset-Impuls an Pin 6 in den Bootloader-Modus. Es kann sofort eine Firmware (das Anwenderprogramm) mit einer Programmer-Software hochgeladen werden. Damit man nicht immer bei der Softwareentwicklung diesen Jumper ständig stecken und abziehen muss, gibt es noch die Programmier-Automatik mittels der beiden Handshake-Leitungen RTS und DTR. Eine Programmer-Software kann diese beiden Leitungen der RS232-Schnittstelle schalten und damit den Mikrocontroller gezielt in den Bootloader-Modus bringen, die Firmware übertragen und anschließend das Programm starten. Der MP2103-Stick muss bei der Softwareentwicklung nicht angefasst werden. Alles geschieht vom PC aus. Im endgültigen Normalbetrieb müssen S2 offen und BSL_HAND nicht gesteckt sein. In welchen Modus der Mikrocontroller geschaltet werden soll entscheidet der Signalpegel an Pin 44 des LPC2103 bei einem Reset-Impuls. High = Normalbetrieb, Low = Bootloader.
Sehr einfach gestaltet sich die Beschaltung des externen seriellen Flash-Speichers IC2.
Es können die ICs AT45DB321D-SU (4MB), AT45DB161D-SU (2MB) oder AT45DB081D-SU (1MB) eingelötet werden. Dieser ist mit der SPI des LPC2103 verbunden. Wichtig ist R3! Er wird nur bestückt wenn der Speicher schreibgeschützt sein soll.

== Eagle-Files ==

[[Media:MP2103Stick_v1.0.zip‎|LINK: MP2103Stick_v1.0.zip‎]]

== Mechanische Realisierung ==

Die Leiterplatte sollte von einem Leiterplattenhersteller gefertigt werden. Ich habe die Erfahrung gemacht, dass Anbieter mit Preis-Berechnungen auf Quadratdezimeter-Basis egal mit welchem Inhalt die günstigsten sind. Wichtig ist, dass die Leiterplatten mit Durchkontaktierungen gefertigt werden. Aus Erfahrung rate ich die Leiterplatten mit Lötstopplack fertigen zu lassen. Einfach die Datei „MP03Stick_v1.0.brd“ dem Hersteller schicken.

Board top:

[[Bild:MP03Stick_board_top_klein.GIF]]

Board bottom:

[[Bild:MP03Stick_board_bottom_klein.GIF]]

Stueckliste:

[[Bild:MP2103Stick_Stueckliste.PNG]]

== Bestückung der Leiterplatte ==

Elektronische Bauteile sind durch elektrostatische Ladungen gefährdet. Deshalb ab jetzt mit ESD-Armband und ESD-Unterlage arbeiten!!!
Beim Arbeiten mit den kleinen Bauteilen hilft auf jeden Fall ein Briefmarken-Lupen-Headset oder ein Stereo-Mikroskop mit Verstärkungsfaktor 10 (bei ebey ca. 200,- €).
Zuerst die beiden großen ICs, IC3 (LPC2103) und IC4 (FT232RL), bestücken. Da es sich um ziemlich kleine und mit hoher Pin-Anzahl versehene elektronische Bauteile handelt, empfehle ich folgende Vorgehensweise: Die Lötpads auf der Leiterplatte für das entsprechende IC reichlich mit dem Lötkolben und Lötzinn (<= 0,5 mm Durchmesser) verzinnen. Die Lötpads sollten glänzen und um ca. 0,1 bis 0,2 mm erhaben sein. Nun die Leiterplatte mit handelsüblichem Brennspiritus reinigen. Jetzt das IC mit ein wenig Klebstoff auf der Leiterplatte fixieren. Ich nehme dafür handelsüblichen Klebestift (Pr…-Stift). Eine kleine Messerspitze voll vom Klebestift auf die Mitte der IC-Position auf die Leiterplatte auftragen, das IC auf die Leiterplatte aufsetzen und positionieren. Es darf auf keinen Fall Klebstoff bis zu den Lötanschlüssen des ICs quellen. Erst mit dem Festlöten beginnen, wenn das IC korrekt auf den Lötpads sitzt und etwas angetrocknet ist. Ab jetzt wird nicht mehr mit Lötzinn gearbeitet – dieses am besten so weit wie möglich weglegen. Die Kapillarwirkung der IC-Anschlüsse ist viel zu groß, diese würden eine weitere Zugabe von Lötzinn sofort dieses zwischen die Lötpins ziehen und damit für reichlich Kurzschlüsse sorgen. Ab jetzt wird nur noch mit Flussmittel gearbeitet, entweder handelsübliches Flux oder Kolofonium (in Brennspiritus aufgelöst) nehmen. Ist das IC korrekt positioniert und fixiert mit dem Festlöten beginnen. Jeden einzelnen IC-Anschluss mit dem heißen Lötkolben und wenig Druck in Richtung Leiterplatte anlöten. Wichtig ist wirklich, sich damit Zeit zu lassen und darauf zu achten, dass das Lötzinn richtig fließt. Sollte bei einem der hier beschriebenen Arbeitsschritte etwas schief gehen, unbedingt die Arbeiten abbrechen, alles reinigen und von Anfang beginnen. Sind IC3 und IC4 erfolgreich auf die Leiterplatte gelötet können alle anderen Bauteile bestückt und gelötet werden. Wichtig: „R1!“, „R2!“ und „R3!“ nicht bestücken!!! Die voll bestückte Leiterplatte gründlich mit Brennspiritus und einem kleinen Pinsel reinigen. Die Leiterplatte wegen der Buchsen und Schalter/Taster nicht im Reinigungsmittel baden. Das Reinigungsmittel nicht abtrocknen lassen sondern mit Druckluft entfernen. Es werden so unschöne Flecken vermieden. Sollte der Stick in rauer Umgebung betrieben werden ist das Lackieren mit farblosem Leiterplattenlack sinnvoll.

== Optische Prüfung ==

Jetzt sollte eine ausgiebige Fehlersuche auf Kurzschlüsse, kalte Lötstellen, Verpolung von Bauteilen und richtiger Bestückung erfolgen. Entweder mit einer großen Lupe oder einem Stereo-Mikroskop mit Vergrößerungsfaktor 10.

Alle weiteren Arbeitsschritt erst nach vollständiger Trocknung des Stick durchführen.

== Elektrische Inbetriebnahme ==

Für erste Tests ist es am Besten den Stick mit einem Strom geregelten Netzteil über die USB-Buchse (Pin1 +5V, Pin4 Masse) zu verbinden; den Strom auf 50 mA begrenzen und 5 Volt einstellen. Nach Einschalten sollte ein Strom von ca. 10 bis 20 mA fließen und die anliegende Spannung weiterhin 5 Volt betragen. Bricht die Spannung zusammen auf keinen Fall die Strombegrenzung erhöhen sondern auf Kurzschlusssuche gehen. Fließt zu wenig Strom oder keiner kalte Lötstellen suchen. Ist kein Netzteil vorhanden, einfach drei kleine billige Knopfzellen á 1,5 Volt in Reihe schalten und den Strom mit einem Multimeter messen. Stimmt der Strom und liegen die 5 Volt an, die Spannungen an den Testpunkten TP1 bis TP4 überprüfen. Bezugspunkt ist TPM (Masse). Folgende Spannungen sollten gemessen werden:

TP1 = 1,8 Volt

TP2 = 3,3 Volt

TP3 = 5 Volt (oder 4,5V bei der Variante mit den drei 1,5V Knopfzellen)

TP4 = 3,3 Volt

Wenn diese Spannungen OK sind kann der Stick an den PC/Notebook über ein USB-Kabel angeschlossen werden. Nun sollte das Betriebssystem (Windows, für WinCE, Linux und Mac weiß ich es nicht) melden, dass neue Hardware erkannt wurde. Jetzt kann der Treiber für den FT232RL installiert werden. Den Treiber (Virtual COM Port, VCP) von der [http://ftdichip.com Herstellerseite] downloaden – die Vorgehensweise ist dort ausführlich beschrieben. Nach erfolgreicher Installation des Treibers sollte im Hardwaremanager ein neuer COMx-Port zu sehen sein. Die COM-Nummer sollte man sich merken. Windows registriert für jede USB-Schnittstelle eine andere COM-Port-Nummer, was zu Verwirrung beim Umstecken führen kann. Damit sind aber auch mehrere Sticks anschließbar.

[http://ftdichip.com/Drivers/VCP.htm LINK: die Treiber für den FT232RL]

[http://ftdichip.com/Documents/InstallGuides.htm LINK: Driver Installation Guides]

Sind alle Tests und Arbeitsschritte bis hier OK können die beiden Widerstände „R1!“ und „R2!“ eingelötet werden um den Mikrocontroller mit Strom zu versorgen. Es sollte ein Strom zwischen 20 und 40 mA fließen, wenn nicht: Fehlersuche nach Kurzschlüssen, kalten Lötstellen, verpolten Bauteilen und falscher Bestückung. Sind die beiden Dip-Schalter von S2 offen (nicht auf ON) und der Jumper BSL_Hand gezogen sollte die LED leuchten.

== Firmware Upload ==

Zum Hochladen der Firmware benötigt man das Programm Flash-Magic-Tool.

[http://www.flashmagictool.com/ LINK: Flash Magig Tool]

Die Einstellungen sind folgende:

Unter „Step 1 - Communications“:

Com Port: der COMx-Port, an dem der MP2103-Stick angeschlossen ist. Im Hardwaremanager nachsehen!

Baud Rate: 115200

Device: LPC2103

Interface: None (ISP)

Oscillator Freq. (MHz): 14.7456

Unter „Step 2 - Erase“:

Ein Hägchen hinter: „Erase all Flash+Code Rd Prot“

Ùnter „Step 3 – Hex File“:

Das Hex-File, welches hochgeladen werden soll.

Unter „Step 4 – Options“:

Hinter „Verify after programming“

Unter Adanced Options im Formular „Hardware Options“ ein Häckchen hinter „Use DTR and RTS to control RTS and P0.14“

[[Bild:FlashMagicFlashen.GIF]]

[[Bild:FlashMagicAdvanstOption.GIF]]

Jetzt am Besten erst einmal testen, ob sich der Mikrocontroller meldet. Die beiden Dip-Schalter von S2 müssen auf „ON“ stehen und Jumper „BSL_HAND“ muss gezogen sein. Flash Magic starten, die Einstellungen wie oben und in der Menüleiste „ISP“ den Menüpunk „Read Device Signatur“ anwählen. Der Mikrocontroller muss in dem sich öffnenden Fenster die Divice-ID und die Bootloaderversion liefern. Meldet Magic Flash einen Fehler: Fehlersuche. :O(

[[Bild:FlashMagicReadDeviceSegnature.GIF]]

[[Bild:FlashMagicDeviceSignature.GIF]]

Den Firmware-Upload startet man mit dem Button "Start" unter "Step 5 - Start!" im Falsh Magic.

Ein weiteres Flash-Tool ist das „LPC2000 Flash Utility“ von Philips, welches leider nicht mehr weiterentwickelt wird. Es ist aber in der Auswahl der COM-Ports begrenzt (COM1 bis COM5). Im Geräte-Manager von Windows müssen bei Bedarf Änderungen an der COM-Port-Nummerierung vorgenommen werden. Bis auf diesen Makel ist dieses Tool schnell und unkompliziert.

[http://www.lpctools.com/downloads/LPC2000%20Flash%20ISP%20Utility%20v2.2.3.zip LINK: LPC2000 Flash Utility]

[[Bild:MP2103Stick_LPC2000Flasher.PNG]]

== Testprojekt ==

Hier ein kleines Testprogramm als Basis für eigene Projekte.
Es lässt die LED blinken und kommuniziert über die serielle Schnittstelle.

[[Media:MP2103-Stick_Test.zip‎|LINK: MP2103-Stick_Test.zip‎]]

Einstellungen im Hyperterminal:

Baud Rate (Bits pro Sekunde): 921600

Einstellungen/Emulation: ANSI

Die genauen Einstellungen befinden sich im Projekt unter MP2103-Stick_921600_baud.ht.

[[Bild:MP2103_Terminal.GIF]]

Compiliert wird das Projekt mit WinARM oder Yagarto.

[http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/ LINK: WinARM]

[http://www.yagarto.de/ LINK: Yagarto]

== Compiler und IDE (neu) ==

Die Integrierte Entwicklungsumgebung von Raisonance, Ride7 und RKit-ARM, umfasst einen voll funktionsfähigen und Code unbegrenzten GNU C/C++-Compiler und das Raisonance Integrated Development Environment (RIDE). Über eine grafische Benutzeroberfläche wird die Bedienung der Softwareentwicklungs-Tools (Compiler, Assembler, Linker und Simulator) ermöglicht. Für die Softwareentwicklung und Kompilierung vom C-Source-Code bis hin zum endgültigen HEX-File besteht keine Codegrößenbegrenzung, lediglich das Debugging ist bis 32kByte begrenzt. Das ist aber hier nicht von Belang, da mit dem Bootloader des Mikrocontrollers geflasht wird.

[[Bild:MP2103Stick_Ripe7.PNG]]

Auf der Page von Raisonance.com anmelden und die Files "RKit-ARM" (GCC) und "Ride7" (IDE) downloaden und installieren. Zuerst RKit-ARM dann Ride7. Der Umgang mit diesen Programmen ist super einfach - keine Rumquälerei mit Makefiles und solcherlei Teufelszeug - alles ist bereits Mundgerecht von Raisonance zugeschneidert. Sehr empfehlenswert! Ride7 ist eigentlich nicht für den LPC2103 ausgelegt, aber mit ein wenig Überredungskunst geht dieses auch.

[http://www.mcu-raisonance.com/mcu_downloads.html LINK: Compiler und IDE Ride7 von Raisonance.com]

[http://www.mcu-raisonance.com/tzr/scripts/downloader2.php?filename=T020/file/d8/cd/4datj7g5d1wr&mime=application/pdf&originalname=GettingStartedARM_Ride7.pdf LINK: Getting Started with ARM & Ride7 User manual]

Und wie einfach alles ist zeigt dieses Beipiel-Projekt:

[[Media:MP2103Stick_Hello_World.zip|LINK: Hello-World-Projekt mit Ride7]]

Da in Ride7 kein serielles Upload-Tool für den MP2103-Stick integriert ist, kann zum Hochladen der Firmware (Hello_World.hex) „LPC2000 Flash Utility“ von Philips oder Flash-Magic genommen werden.

== Fazit ==

Es wurde ein kleines Arm7-Mikrocontroller-Board mit beachtlichen Leistungsmerkmalen und sehr geringen Herstellungskosten vorgestellt.

32-Bit-Mikrocontroller 14,7456 bis 58,9824 MHz

32 kByte Flash-ROM

8 kByte RAM

bis zu 4MByte Flash-Datenspeicher

jeder Menge Peripherie

Es kann als Standard-Interface-Modul für den PC eingesetzt werden. Es ist so konzipiert, dass es in ein Gehäuse eingebaut und mit vier M2-Schrauben befestigt werden kann. Auf den beiden Wannensteckerleisten CON1 und CON2 kann ein Tochterboard über zwei 16-polige Pfostenbuchsenleisten mit individueller Elektronik aufgesteckt werden (conrad.de Artikel-Nr.: 738501-62).

Ich stelle mir folgende Einsatzbeispiele vor:

Interface für einen Roboter

Logik-Analysator

Datenlogger für analoge Signale

Oszilloskop

Einsatz in Computer gesteuerten Messgeräten

CNC-Maschinen

usw.

Überall, wo ein Interface für den PC benötigt wird, kann der MP2103-Stick eingesetzt werden. Im Stick laufen nur die Treiber für die Peripherie und eine Transport-Routine für die Rohdaten vom und zum PC - die eigentliche Software läuft auf dem PC.

Übrigens:

Der Board-Computer der Mondlandefähre von Apollo 11, der [http://www.ibiblio.org/apollo/ "Apollo Guidance Computer"], hatte einen 16-Bit-Computer mit 2,048 MHz, 72 kByte ROM und 4 kByte RAM.

[[Category:ARM-Boards]]
[[Category:USB]]