Mikrocontroller.net - Benutzerbeiträge [de]

STM32F103C8T6 STM32 Billig Board

2017-08-11T20:24:39Z

Kruemeltee:

= Übersicht =
Bei Aliexpress, Ebay & Co gibt es bereits ab 2 EUR (1.84€ [19.07.2017]) ein minimalistisches STM32-Board.
Auf Ebay im Suchfeld Suchfeld einfach "STM32F103C8T6" eingeben.
[[Datei:STM32F103C8T6 STM32 Board.jpg|mini]]
Eckdaten:
* STM32F103C8T6
* 64k Flash (viele C8 besitzen in wirklichkeit 128k Flash), 20k RAM
* Micro-USB, ISP Header (SWDIO)
* 8MHz System-Quarz, 32.768kHz RTC Quarz
* BOOT0/BOOT1 Jumper
* RESET Button
* Power LED, LED an GPIO

Dieses Board ist unter anderem auch unter dem Namen '''Blue Pill''' bekannt. Zwei ähnliche Boards nennen sich "Black Pill" und "Red Pill".
= Schaltplan =
Es scheint verschiedene Versionen dieses Boards zu geben und das sorgt für Verwirrung. Bei der geringen Anzahl an Bauteilen sollte man genau mit Fotos und Schaltplan vergleichen. Am besten jeden Bauteilwert verifizieren.

Der Hersteller scheint eine Website unter der Domain ''vcc-gnd.com'' gehabt zu haben, dort gab es einen Schaltplan, der noch im Netz umgeht ([[Datei:vcc-gnd.com-blue-pill-schematic-stm32f103c8t6.pdf|dieser]]).

Der User ''Eddy Current (chrisi)'' hat dafür in diesem [https://www.mikrocontroller.net/topic/350400 Thread] einen Schaltplan gepostet ([[Datei:STM32 Min System Dev Board.pdf|Schaltplan]]).

= Inbetriebnahme und Test =
Die onboard-LED an PC13 kann man für erste Lebenszeichen verwendet werden.
Hier gibt es ein kleines blinky-Programm https://github.com/spacerace/stm32f103c8t6-blinky im Quellcode und
[[hier als Binary|stm32f103c8t6_blinky.bin]] zum direkten schreiben.

= 128k Flash =

= In System Programming/Programmer =
Durch den SWDIO Header lässt sich das Board sehr einfach per ST-Link und kompatiblem Programmern schreiben/lesen.
Mit einer passenden Firmware lässt sich dieses Board auch ST-LinkV2 verwenden.

= USB PullUp Problem =
R10 ist auf vielen Boards mit 10k bestückt worden und sollte aber ein 1k5 Widerstand sein. Dadurch muss nach jedem
Reset das Board ab- und wieder angesteckt werden.
Man hat nun zwei Möglichkeiten, man wechselt R10 aus oder schliesst einen 1k8 parallel zu R10 an.
Nun hat man wieder die Möglichkeit das an-/abstecken per Software vorzugeben.
[[Kategorie:ARM]]
[[Kategorie:STM32]]

STM32F103C8T6 STM32 Billig Board

2017-08-11T20:23:49Z

Kruemeltee:

Bei Aliexpress, Ebay & Co gibt es bereits ab 2 EUR (1.84€ [19.07.2017]) ein minimalistisches STM32-Board.
Auf Ebay im Suchfeld Suchfeld einfach "STM32F103C8T6" eingeben.
[[Datei:STM32F103C8T6 STM32 Board.jpg|mini]]
Eckdaten:
* STM32F103C8T6
* 64k Flash (viele C8 besitzen in wirklichkeit 128k Flash), 20k RAM
* Micro-USB, ISP Header (SWDIO)
* 8MHz System-Quarz, 32.768kHz RTC Quarz
* BOOT0/BOOT1 Jumper
* RESET Button
* Power LED, LED an GPIO

Dieses Board ist unter anderem auch unter dem Namen '''Blue Pill''' bekannt. Zwei ähnliche Boards nennen sich "Black Pill" und "Red Pill".
= Schaltplan =
Es scheint verschiedene Versionen dieses Boards zu geben und das sorgt für Verwirrung. Bei der geringen Anzahl an Bauteilen sollte man genau mit Fotos und Schaltplan vergleichen. Am besten jeden Bauteilwert verifizieren.

Der Hersteller scheint eine Website unter der Domain ''vcc-gnd.com'' gehabt zu haben, dort gab es einen Schaltplan, der noch im Netz umgeht ([[Datei:vcc-gnd.com-blue-pill-schematic-stm32f103c8t6.pdf|dieser]]).

Der User ''Eddy Current (chrisi)'' hat dafür in diesem [https://www.mikrocontroller.net/topic/350400 Thread] einen Schaltplan gepostet ([[Datei:STM32 Min System Dev Board.pdf|Schaltplan]]).

= Inbetriebnahme und Test =
Die onboard-LED an PC13 kann man für erste Lebenszeichen verwendet werden.
Hier gibt es ein kleines blinky-Programm https://github.com/spacerace/stm32f103c8t6-blinky im Quellcode und
[[hier als Binary|stm32f103c8t6_blinky.bin]] zum direkten schreiben.

= 128k Flash =

= In System Programming/Programmer =
Durch den SWDIO Header lässt sich das Board sehr einfach per ST-Link und kompatiblem Programmern schreiben/lesen.
Mit einer passenden Firmware lässt sich dieses Board auch ST-LinkV2 verwenden.

= USB PullUp Problem =
R10 ist auf vielen Boards mit 10k bestückt worden und sollte aber ein 1k5 Widerstand sein. Dadurch muss nach jedem
Reset das Board ab- und wieder angesteckt werden.
Man hat nun zwei Möglichkeiten, man wechselt R10 aus oder schliesst einen 1k8 parallel zu R10 an.
Nun hat man wieder die Möglichkeit das an-/abstecken per Software vorzugeben.
[[Kategorie:ARM]]
[[Kategorie:STM32]]

STM32F103C8T6 STM32 Billig Board

2017-08-11T20:17:52Z

Kruemeltee: Überarbeiten und Erweitern

Datei:Vcc-gnd.com-blue-pill-schematic-stm32f103c8t6.pdf

2017-08-11T20:15:11Z

Kruemeltee: Schaltplan des blauen STM32F103C8T6 dev Boards von aliexpress, ebay und co. Nennt sich auch "Blue Pill".

Schaltplan des blauen STM32F103C8T6 dev Boards von aliexpress, ebay und co.
Nennt sich auch "Blue Pill".

STM32F103C8T6 STM32 Billig Board

2017-02-05T20:05:45Z

Kruemeltee: ...

Bei Aliexpress, Ebay & Co gibt es bereits ab 3 EUR ein minimalistisches STM32-Board. Auf Ebay im Suchfeld Suchfeld einfach "STM32F103C8T6" eingeben.

[[Datei:STM32F103C8T6 STM32 Board.jpg|mini]]

Eddy Current (chrisi) hat dafür in dem [https://www.mikrocontroller.net/topic/350400 Thread] einen Schaltplan gepostet: [[Datei:STM32 Min System Dev Board.pdf|gerahmt]]

Die onboard-LED an PC13 kann man für erste Lebenszeichen verwendet werden. Hier gibt es ein kleines blinky-Programm: https://github.com/spacerace/stm32f103c8t6-blinky .

Hier ausserdem nochmal compiliert:
[[Datei:stm32f103c8t6_blinky.bin|stm32f103c8t6_blinky.bin]]

[[Kategorie:ARM]]
[[Kategorie:STM32]]

Datei:Stm32f103c8t6 blinky.bin

2017-02-05T20:03:19Z

Kruemeltee: blinky on PC13

blinky on PC13

STM32F103C8T6 STM32 Billig Board

2017-02-05T20:02:29Z

Kruemeltee: Blinky

Bei Aliexpress, Ebay & Co gibt es gibt ab 3 EUR aufwärts ein STM32 Board, einfach nach "STM32F103C8T6" suchen.

Eddy Current (chrisi) hat dafür in dem [https://www.mikrocontroller.net/topic/350400 Thread] einen Schaltplan gepostet:

[[Datei:STM32 Min System Dev Board.pdf|gerahmt]]

Und ein Bild davon:

[[Datei:STM32F103C8T6 STM32 Board.jpg|mini]]

Die onboard-LED an PC13 kann für erste Lebenszeichen verwendet werden. Hier gibt es ein kleines blinky-Programm: https://github.com/spacerace/stm32f103c8t6-blinky .

Hier ausserdem nochmal compiliert:
[[Datei:stm32f103c8t6_blinky.bin|stm32f103c8t6_blinky.bin]]

[[Kategorie:ARM]]
[[Kategorie:STM32]]

STM32 jump to bootloader

2016-06-30T20:09:38Z

Kruemeltee: /* Beispiel */

'''STM32 - Jump To Bootloader'''

In manchen Anwendungen möchte man keinen Hardwarebutton für ein Firmware-Update haben. Muss man trotzdem ab und zu ein Update einspielen, kann man den Bootloader über eine versteckte UI-Funktion aufrufen oder einen Befehl über die serielle Schnittstelle senden um den Bootloader anzuspringen.
Die Möglichkeiten sind sehr vielfältig.

Die hier beschriebene Möglichkeit schreibt eine Magic-Konstante in's RAM. Dieses überlebt einen System-Reset und der veränderte Startup-Code prüft auf diese Konstante. Ist diese vorhanden, wird zum Bootloader gesprungen.

Der Code zum Prüfen und Verzweigen wird kurz vor dem Aufruf der main()-Funktion eingefügt. Kurz dahinter kommt die Subroutine 'Reboot_Loader'. Diese setzt einen Pointer auf den Bootloader und hüpft dann dort hin.

===== startup.S =====
<syntaxhighlight lang="asm">
/* Call the clock system intitialization function.*/
bl SystemInit

/* check for a magic constant in RAM, if present
* brach to bootloader */
LDR R0, =0x2000FFF0
LDR R1, =0xDEADBEEF
LDR R2, [R0, #0]
STR R0, [R0, #0] /* Invalidate*/
CMP R2, R1
BEQ Reboot_Loader

/* Call the applications entry point.*/
bl main
bx lr
.size Reset_Handler, .-Reset_Handler

Reboot_Loader:
LDR R0, =0x1FFFF000
LDR SP,[R0, #0]
LDR R0,[R0, #4]
BX R0
</syntaxhighlight>

===== app.c =====
<syntaxhighlight lang="c">
*((unsigned long *)0x2000FFF0) = 0xDEADBEEF; // 64KB STM32F103, also works with 512k STM32F103VCT6
NVIC_GernerateSystemReset();
</syntaxhighlight>

===== app.c ohne fwlib/HAL =====
<syntaxhighlight lang="c">
#define AIRCR_VECTKEY_MASK ((uint32_t)0x05FA0000)

*((unsigned long *)0x2000FFF0) = 0xDEADBEEF; // 64KB STM32F103, also works with 512k STM32F103VCT6
SCB->AIRCR = AIRCR_VECTKEY_MASK | (u32)0x04;
</syntaxhighlight>

=== Beispiel ===

Der folgende Code-Ausschnitt zeigt die ISR des USART1 eines STM32F103. Der Code sammelt alle empfangenen Bytes und zählt mit. Sobald 32bytes oder ein '\r' empfangen wurden, wird der String verglichen. Ist dieser "GBL\r", springt er in den Bootloader.

Auf dem Programmier-Computer läuft ein kurzes Python-Script, welches "GBL\r" sendet und danach wird direkt das Flash-Update-Tool wie stm32flash aufgerufen. So entfällt jegliches Bedienen am Gerät.

Das Python-Script heisst gbl.py, danach der Aufruf zum flashen:

'''$ ./gbl.py && stm32flash -b 921600 -w output/main.bin -g 0x0 /dev/ttyUSB0'''

Das Python-Script benötigt das Paket python-serial.
<syntaxhighlight lang="python">
#!/usr/bin/python

import serial

ser = serial.Serial('/dev/ttyUSB0', 115200)
print ser.name
ser.write('GBL\r')
ser.close
</syntaxhighlight>

Nun der Controller-Teil. Zuerst die ISR, danach die Initialisierung sowie einfache putc/puts Funktionen.

<syntaxhighlight lang="c">
void USART1_IRQHandler(void) {
char c;

static int count = 0;
static char rcv[33];

if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
c = (char)USART_ReceiveData(USART1);

rcv[count] = c;
count++;

if((count == 32) || (c == '\r')) {
rcv[count] = '\0';
//usart1_puts(rcv);

if(!(strcmp(rcv, "GBL\r"))) { // go to bootloader
/* write constant to ram */
*((unsigned long *)0x2000FFF0) = 0xDEADBEEF;

/* do a system reset */
SCB->AIRCR = ((uint32_t)0x05FA0000) | (u32)0x04;
//} else if(!(strcmp(rcv, "HELP\r"))) {
// print_help();
} else {
usart1_puts("?! < no cmd >\n");
}

count = 0;
memset(rcv, 0, 33);
}

//USART_SendData(USART1, c);
USART_ClearITPendingBit(USART1, USART_IT_RXNE);
}
}

void usart1_init(void) {
USART_InitTypeDef usart_i;
GPIO_InitTypeDef gpio_i;

GPIO_PinRemapConfig(GPIO_Remap_USART1,DISABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);

/* TX */
gpio_i.GPIO_Pin = GPIO_Pin_9;
gpio_i.GPIO_Speed = GPIO_Speed_50MHz;
gpio_i.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &gpio_i);

/* RX */
gpio_i.GPIO_Pin = GPIO_Pin_10;
gpio_i.GPIO_Speed = GPIO_Speed_50MHz;
gpio_i.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &gpio_i);

/* 115200 8n1 */
usart_i.USART_BaudRate = 115200;
usart_i.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
usart_i.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
usart_i.USART_Parity = USART_Parity_No;
usart_i.USART_StopBits = USART_StopBits_1;
usart_i.USART_WordLength = USART_WordLength_8b;

USART_Init(USART1, &usart_i);

/* enable RXNE interrupt */
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
NVIC_EnableIRQ(USART1_IRQn);

USART_Cmd(USART1,ENABLE);
}

void usart1_putc(char c){
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
USART_SendData(USART1, c);
return;
}

void usart1_puts(char *str){
while(*str != 0) {
usart1_putc(*(str++));
}
return;
}

</syntaxhighlight>

=== Nachteile / Beachten ===

Der Bootloader erwartet einen gewissen Status der Peripherie, was nicht von ST dokumentiert wurde. In meiner jetzigen Applikation habe ich mit dieser Methoder bisher keine Probleme. Andere User im ST-Forum berichten von Problemen beim Anspringen des Bootloaders. Eventuell muss dann noch von Hand Peripherie deinitialisiert werden um die korrekte Funktion zu gewährleisten.
Siehe ST-Forum-Lunk unter "Quellen".

=== Quellen ===
* https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FJump%20to%20internal%20bootloader&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=8841

=== Autor ===
clive1 - ST-Forum (code)

Nils S. - µC.net (Artikel)

STM32 jump to bootloader

2016-06-30T20:08:43Z

Kruemeltee: /* Beispiel */

'''STM32 - Jump To Bootloader'''

In manchen Anwendungen möchte man keinen Hardwarebutton für ein Firmware-Update haben. Muss man trotzdem ab und zu ein Update einspielen, kann man den Bootloader über eine versteckte UI-Funktion aufrufen oder einen Befehl über die serielle Schnittstelle senden um den Bootloader anzuspringen.
Die Möglichkeiten sind sehr vielfältig.

Die hier beschriebene Möglichkeit schreibt eine Magic-Konstante in's RAM. Dieses überlebt einen System-Reset und der veränderte Startup-Code prüft auf diese Konstante. Ist diese vorhanden, wird zum Bootloader gesprungen.

Der Code zum Prüfen und Verzweigen wird kurz vor dem Aufruf der main()-Funktion eingefügt. Kurz dahinter kommt die Subroutine 'Reboot_Loader'. Diese setzt einen Pointer auf den Bootloader und hüpft dann dort hin.

===== startup.S =====
<syntaxhighlight lang="asm">
/* Call the clock system intitialization function.*/
bl SystemInit

/* check for a magic constant in RAM, if present
* brach to bootloader */
LDR R0, =0x2000FFF0
LDR R1, =0xDEADBEEF
LDR R2, [R0, #0]
STR R0, [R0, #0] /* Invalidate*/
CMP R2, R1
BEQ Reboot_Loader

/* Call the applications entry point.*/
bl main
bx lr
.size Reset_Handler, .-Reset_Handler

Reboot_Loader:
LDR R0, =0x1FFFF000
LDR SP,[R0, #0]
LDR R0,[R0, #4]
BX R0
</syntaxhighlight>

===== app.c =====
<syntaxhighlight lang="c">
*((unsigned long *)0x2000FFF0) = 0xDEADBEEF; // 64KB STM32F103, also works with 512k STM32F103VCT6
NVIC_GernerateSystemReset();
</syntaxhighlight>

===== app.c ohne fwlib/HAL =====
<syntaxhighlight lang="c">
#define AIRCR_VECTKEY_MASK ((uint32_t)0x05FA0000)

*((unsigned long *)0x2000FFF0) = 0xDEADBEEF; // 64KB STM32F103, also works with 512k STM32F103VCT6
SCB->AIRCR = AIRCR_VECTKEY_MASK | (u32)0x04;
</syntaxhighlight>

=== Beispiel ===

Der folgende Code-Ausschnitt zeigt die ISR des USART1 eines STM32F103. Der Code sammelt alle empfangenen Bytes und zählt mit. Sobald 32bytes oder ein '\r' empfangen wurden, wird der String verglichen. Ist dieser "GBL\r", springt er in den Bootloader.

Auf dem Programmier-Computer läuft ein kurzes Python-Script, welches "GBL\r" sendet und danach wird direkt das Flash-Update-Tool wie stm32flash aufgerufen. So entfällt jegliches Bedienen am Gerät.

Das Python-Script heisst gbl.py, danach der Aufruf zum flashen:

'''$ ./gbl.py && stm32flash -b 921600 -w output/main.bin -g 0x0 /dev/ttyUSB0'''

Das Python-Script benötigt das Paket python-serial.
<syntaxhighlight lang="python">
#!/usr/bin/python

import serial

ser = serial.Serial('/dev/ttyUSB0', 115200)
print ser.name
ser.write('GBL\r')
ser.close
</syntaxhighlight>

Nun der Controller-Teil. Zuerst die ISR, danach die Initialisierung sowie einfache putc/puts Funktionen.

<syntaxhighlight lang="c">
void USART1_IRQHandler(void) {
char c;

static int count = 0;
static char rcv[33];

if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
c = (char)USART_ReceiveData(USART1);

rcv[count] = c;
count++;

if((count == 32) || (c == '\r')) {
rcv[count] = '\0';
lcd_con_puts(rcv);

if(!(strcmp(rcv, "GBL\r"))) { // go to bootloader
/* write constant to ram */
*((unsigned long *)0x2000FFF0) = 0xDEADBEEF;

/* do a system reset */
SCB->AIRCR = ((uint32_t)0x05FA0000) | (u32)0x04;
//} else if(!(strcmp(rcv, "HELP\r"))) {
// print_help();
} else {
usart1_puts("?! < no cmd >\n");
}

count = 0;
memset(rcv, 0, 33);
}

//USART_SendData(USART1, c);
USART_ClearITPendingBit(USART1, USART_IT_RXNE);
}
}

void usart1_init(void) {
USART_InitTypeDef usart_i;
GPIO_InitTypeDef gpio_i;

GPIO_PinRemapConfig(GPIO_Remap_USART1,DISABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);

/* TX */
gpio_i.GPIO_Pin = GPIO_Pin_9;
gpio_i.GPIO_Speed = GPIO_Speed_50MHz;
gpio_i.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &gpio_i);

/* RX */
gpio_i.GPIO_Pin = GPIO_Pin_10;
gpio_i.GPIO_Speed = GPIO_Speed_50MHz;
gpio_i.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &gpio_i);

/* 115200 8n1 */
usart_i.USART_BaudRate = 115200;
usart_i.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
usart_i.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
usart_i.USART_Parity = USART_Parity_No;
usart_i.USART_StopBits = USART_StopBits_1;
usart_i.USART_WordLength = USART_WordLength_8b;

USART_Init(USART1, &usart_i);

/* enable RXNE interrupt */
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
NVIC_EnableIRQ(USART1_IRQn);

USART_Cmd(USART1,ENABLE);
}

void usart1_putc(char c){
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
USART_SendData(USART1, c);
return;
}

void usart1_puts(char *str){
while(*str != 0) {
usart1_putc(*(str++));
}
return;
}

</syntaxhighlight>

=== Nachteile / Beachten ===

Der Bootloader erwartet einen gewissen Status der Peripherie, was nicht von ST dokumentiert wurde. In meiner jetzigen Applikation habe ich mit dieser Methoder bisher keine Probleme. Andere User im ST-Forum berichten von Problemen beim Anspringen des Bootloaders. Eventuell muss dann noch von Hand Peripherie deinitialisiert werden um die korrekte Funktion zu gewährleisten.
Siehe ST-Forum-Lunk unter "Quellen".

=== Quellen ===
* https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FJump%20to%20internal%20bootloader&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=8841

=== Autor ===
clive1 - ST-Forum (code)

Nils S. - µC.net (Artikel)

STM32 jump to bootloader

2016-06-30T20:07:54Z

Kruemeltee: Beispiel hinzugefügt (python, stm32loader, usart1_irq)

'''STM32 - Jump To Bootloader'''

In manchen Anwendungen möchte man keinen Hardwarebutton für ein Firmware-Update haben. Muss man trotzdem ab und zu ein Update einspielen, kann man den Bootloader über eine versteckte UI-Funktion aufrufen oder einen Befehl über die serielle Schnittstelle senden um den Bootloader anzuspringen.
Die Möglichkeiten sind sehr vielfältig.

Die hier beschriebene Möglichkeit schreibt eine Magic-Konstante in's RAM. Dieses überlebt einen System-Reset und der veränderte Startup-Code prüft auf diese Konstante. Ist diese vorhanden, wird zum Bootloader gesprungen.

Der Code zum Prüfen und Verzweigen wird kurz vor dem Aufruf der main()-Funktion eingefügt. Kurz dahinter kommt die Subroutine 'Reboot_Loader'. Diese setzt einen Pointer auf den Bootloader und hüpft dann dort hin.

===== startup.S =====
<syntaxhighlight lang="asm">
/* Call the clock system intitialization function.*/
bl SystemInit

/* check for a magic constant in RAM, if present
* brach to bootloader */
LDR R0, =0x2000FFF0
LDR R1, =0xDEADBEEF
LDR R2, [R0, #0]
STR R0, [R0, #0] /* Invalidate*/
CMP R2, R1
BEQ Reboot_Loader

/* Call the applications entry point.*/
bl main
bx lr
.size Reset_Handler, .-Reset_Handler

Reboot_Loader:
LDR R0, =0x1FFFF000
LDR SP,[R0, #0]
LDR R0,[R0, #4]
BX R0
</syntaxhighlight>

===== app.c =====
<syntaxhighlight lang="c">
*((unsigned long *)0x2000FFF0) = 0xDEADBEEF; // 64KB STM32F103, also works with 512k STM32F103VCT6
NVIC_GernerateSystemReset();
</syntaxhighlight>

===== app.c ohne fwlib/HAL =====
<syntaxhighlight lang="c">
#define AIRCR_VECTKEY_MASK ((uint32_t)0x05FA0000)

*((unsigned long *)0x2000FFF0) = 0xDEADBEEF; // 64KB STM32F103, also works with 512k STM32F103VCT6
SCB->AIRCR = AIRCR_VECTKEY_MASK | (u32)0x04;
</syntaxhighlight>

=== Beispiel ===

Der folgende Code-Ausschnitt zeigt die ISR des USART1 eines STM32F103. Der Code sammelt alle empfangenen Bytes und zählt mit. Sobald 32bytes oder ein '\r' empfangen wurden, wird der String verglichen. Ist dieser "GBL\r", springt er in den Bootloader.

Auf dem Programmier-Computer läuft ein kurzes Python-Script, welches "GBL\r" sendet und danach wird direkt das Flash-Update-Tool wie stm32flash aufgerufen. So entfällt jegliches Bedienen am Gerät.

Das Python-Script heisst gbl.py, danach der Aufruf zum flashen:

'''$ ./gbl.py && stm32flash -b 921600 -w output/main.bin -g 0x0 /dev/ttyUSB0'''

Das Python-Script benötigt das Paket python-serial.
<syntaxhighlight lang="python">
#!/usr/bin/python

import serial

ser = serial.Serial('/dev/ttyUSB0', 115200)
print ser.name
ser.write('GBL\r')
ser.close
</syntaxhighlight>

Nun der Controller-Teil. Zuerst die ISR, danach die Initialisierung sowie einfache putc/puts Funktionen.

<syntaxhighlight lang="c">
void USART1_IRQHandler(void) {
char c;

static int count = 0;
static char rcv[33];

if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
c = (char)USART_ReceiveData(USART1);

rcv[count] = c;
count++;

if((count == 32) || (c == '\r')) {
rcv[count] = '\0';
lcd_con_puts(rcv);

if(!(strcmp(rcv, "GBL\r"))) { // go to bootloader
/* write constant to ram */
*((unsigned long *)0x2000FFF0) = 0xDEADBEEF;

/* do a system reset */
SCB->AIRCR = ((uint32_t)0x05FA0000) | (u32)0x04;
//} else if(!(strcmp(rcv, "HELP\r"))) {
// print_help();
} else {
lcd_con_puts("?! < no cmd >\n");
}

count = 0;
memset(rcv, 0, 33);
}

//USART_SendData(USART1, c);
USART_ClearITPendingBit(USART1, USART_IT_RXNE);
}
}

void usart1_init(void) {
USART_InitTypeDef usart_i;
GPIO_InitTypeDef gpio_i;

GPIO_PinRemapConfig(GPIO_Remap_USART1,DISABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);

/* TX */
gpio_i.GPIO_Pin = GPIO_Pin_9;
gpio_i.GPIO_Speed = GPIO_Speed_50MHz;
gpio_i.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &gpio_i);

/* RX */
gpio_i.GPIO_Pin = GPIO_Pin_10;
gpio_i.GPIO_Speed = GPIO_Speed_50MHz;
gpio_i.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &gpio_i);

/* 115200 8n1 */
usart_i.USART_BaudRate = 115200;
usart_i.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
usart_i.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
usart_i.USART_Parity = USART_Parity_No;
usart_i.USART_StopBits = USART_StopBits_1;
usart_i.USART_WordLength = USART_WordLength_8b;

USART_Init(USART1, &usart_i);

/* enable RXNE interrupt */
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
NVIC_EnableIRQ(USART1_IRQn);

USART_Cmd(USART1,ENABLE);
}

void usart1_putc(char c){
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
USART_SendData(USART1, c);
return;
}

void usart1_puts(char *str){
while(*str != 0) {
usart1_putc(*(str++));
}
return;
}

</syntaxhighlight>

=== Nachteile / Beachten ===

Der Bootloader erwartet einen gewissen Status der Peripherie, was nicht von ST dokumentiert wurde. In meiner jetzigen Applikation habe ich mit dieser Methoder bisher keine Probleme. Andere User im ST-Forum berichten von Problemen beim Anspringen des Bootloaders. Eventuell muss dann noch von Hand Peripherie deinitialisiert werden um die korrekte Funktion zu gewährleisten.
Siehe ST-Forum-Lunk unter "Quellen".

=== Quellen ===
* https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Flat.aspx?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FJump%20to%20internal%20bootloader&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B&currentviews=8841

=== Autor ===
clive1 - ST-Forum (code)

Nils S. - µC.net (Artikel)

STM32 jump to bootloader

2016-06-30T08:53:07Z

Kruemeltee: Die Seite wurde neu angelegt: „'''STM32 - Jump To Bootloader''' In manchen Anwendungen möchte man keinen Hardwarebutton für ein Firmware-Update haben. Muss man trotzdem ab und zu ein Upda…“

Benutzer Diskussion:Bohnsorg

2016-03-01T13:06:56Z

Kruemeltee: Die Seite wurde neu angelegt: „Anarchie stinkt, bzw die Leute, die sich das auf die Jacke heften. Ich kann da mitreden, habe lange in Besetzungen gelebt. Genau diese Leute waren der Grund da…“

Anarchie stinkt, bzw die Leute, die sich das auf die Jacke heften. Ich kann da mitreden, habe lange in Besetzungen gelebt. Genau diese Leute waren der Grund das zu beenden.

Was ich dir aber eigentlich sagen will, ich finde das mit dem Wissen verdient haben sehr gut und versuche gleich mir das mal einzuprägen :)
--- Nils

TV-out

2015-10-14T12:07:05Z

Kruemeltee: /* Cinchbuchse */

Bei '''TV-Out''' soll es darum gehen, wie man mit einem [[Mikrocontroller]] ein Bild auf einem Fernseher erzeugen kann.

== Anschluss ==
Ein Fernseher hat oft mehrere Eingänge, die wichtigsten sind der Scartanschluss, die Cinchbuchse ("FBAS"), die Hosidenbuchse ("S-Video") und der Antenneneingang.

=== Scart ===
Am [http://www.darc.de/distrikte/y/00/html/tools/scart.htm Scartanschluss] sind ggf. der FBAS-Eingang, ein S-Video-Eingang, oder auch der RGB-Eingang zu finden; bei Videorecordern ist der RGB-Eingang allerdings nur sehr selten belegt.

=== Cinchbuchse ===
Eine meist gelbe Buchse, an der ebenfalls das [http://www.erft.de/schulen/gymlech/indrevo/indu31/fbas.htm FBAS]-Signal angeschlossen werden kann. Die beiden anderen Buchsen sind für Ton zuständig: Rot für den rechten, Weiss/Schwarz für den linken Kanal.

=== Hosidenbuchse ===
An der vierpoligen Hosidenbuchse werden Helligkeit und Farbe getrennt übertragen.

=== Antenneneingang ===
Damit man viele Sender über ein einziges Kabel übertragen kann, werden diese auf verschiedene Frequenzen moduliert. Das will man aber nicht selbst machen. Wer diesen Eingang benutzen will oder muss, der sollte einen fertigen HF-Modulator benutzen. Im Prinzip ist das ein "Mini-Fernsehsender", der in der Regel in einem bestimmten Bereich auf einen Kanal eigener Wahl eingestellt werden kann (z. B. 39..42). Man findet solche Modulatoren in Katalogen in der Nähe von Kameramodulen (z. B. als "UHF-Modulator") ab etwa 10 EUR.

Wer sich diese 10 EUR sparen will, kann auch versuchen, den Modulator in einem alten Videorekorder zu lokalisieren und auszubauen. Das ist meist gar nicht so schwer, denn da es sich um ein HF-erzeugendes Teil handelt, ist es zur Abschirmung oft in einem "silbernen Kästchen" mit etwa der Größe von ein bis zwei Streichholzschachteln irgendwo in der Nähe der Buchse verbaut, an der der Videorekorder normalerweise mit dem TV-Gerät verbunden wird. Bitte nicht verwechseln mit der Buchse, über die der Videorekorder sein Signal von der (Haus-) Antenne erhält, möglicherweise sitzt dort auch ein abgeschirmtes Kästchen, das wäre dann aber der für TV-Empfang zuständige Tuner. Natürlich muss man dann noch herausfinden, woher der Modulator sein TV-Signal bekommt, welche Versorgungsspannung(en) er braucht, und wenn die Abstimmung auf einen bestimmten Kanal nicht via Poti oder einem anderen, "offensichtlichen" Einsteller erfolgt, muss man auch noch herausfinden, wie dies zu bewerkstelligen ist ... (also vielleicht doch lieber im Katalog nachsehen?)

== Fernsehnormen ==
Die wichtigsten Fernsehnormen sind PAL, NTSC und SECAM. In Europa wird hauptsächlich PAL verwendet, mit Ausnahme von Frankreich und Osteuropa, wo SECAM zum Einsatz kommt. In den USA wird NTSC verwendet. Wenn man auf einem PAL-Fernseher ein NTSC-Bild darstellt, dann ist das Bild etwas kleiner und schwarz-weiß.

== Bilderzeugung ==
Das Bildsignal wird (F)BAS (Farb-Bild-Austast- und Synchronsignal) genannt (englisch: CVBS) und enthält nicht nur das eigentliche Bild, sondern auch Steuerinformationen.

Beim klassischen Röhrenfernseher wird das Bild durch einen Elektronenstrahl erzeugt. Das Bild wird zeilenweise von oben nach unten aufgebaut, die einzelnen Zeilen werden von links nach rechts dargestellt. Wenn der Strahl am Ende einer Zeile angekommen ist, dann muss er für die nächste Zeile wieder an den linken Rand. Diesen Vorgang nennt man den horizontalen Strahlrücklauf; in dieser Zeit ist kein Bild zu sehen. Nach der letzten Zeile muss der Strahl wieder nach oben; dies nennt man den vertikalen Strahlrücklauf.

Das PAL-Fernsehbild hat 625 Zeilen, wovon etwa 570 sichtbar sind. Es werden 50 Halbbilder pro Sekunde dargestellt, also insgesamt 25*625=15625 Zeilen pro Sekunde. Eine Zeile dauert demnach 1s/15625Zeilen = 64 µs/Zeile. Davon sind aber nur 52 µs sichtbar, die andere 12 µs werden für den horizontalen Strahlrücklauf benötigt. Der vertikale Strahlrücklauf dauert 1,5 ms (entspricht 25 Zeilen).

Einen guten Überblick geben Datenblätter zu TV-Impulsgeneratoren, wie sie früher von mehreren Herstellern angeboten wurden. Leider sind sie im Web kaum zu finden:

*[http://www.mikrocontroller.net/wikifiles/3/35/S178A.pdf Siemens S178A]
*[http://www.mikrocontroller.net/wikifiles/b/be/ZNA134.pdf Plessey/Ferranti ZNA134]
*[http://www.mikrocontroller.net/wikifiles/9/9e/ZNA234E.pdf Plessey/Ferranti ZNA234E]
*[http://www.mikrocontroller.net/wikifiles/8/82/SAA1101.pdf Philips SAA1101] oder auch SAA1043/1044
** [http://vss.pl/cq_tv/cq-tv174.pdf Bauvorschlag für einen genlockfähigen PAL-Impulsgenerator mit SAA1101 (ab Seite 31)]

Eine ausführliche Darstellung der Thematik findet sich z. B. bei der [http://web.archive.org/web/*/http://www.avmz.uni-siegen.de/medinfo/download/index.htm Vorlesung Medientechnik II] der Uni Siegen. (Zugriff ist über www.archive.org möglich. Die PDF-Dateien des Vorlesungsskripts (19 MB in 8 Teilen) sind auf dem gleichen Weg erhältlich. Stand 2/2008).

Die Bilderzeugung ist ziemlich rechen- und zeitintensiv, deswegen sollte der Mikrocontroller seine anderen Aufgaben im unsichtbaren Bildbereich erledigen.

=== Schwarzweiß ===
Bei Schwarzweiß- bzw. Graustufenbildern gibt es keine feste Horizontalauflösung. Wenn man z. B. 4 Million Pixel pro Sekunde erzeugen kann, dann ergibt das eben eine Horizontalauflösung von 4000000/15625 * (52 µs / 64 µs) = 208 Pixel.

Weblinks:

* [http://www.whizkidzit.com/ozemail/video_s_w.htm Serielles Terminal] von Ingmar Meins (AT90S8535, PAL)
* [http://jkdesign.de/avrproject/Die%20MAHPONG%20Seite.htm MAHPONG-Spiel] von Marcus Hasenstab (AT90S8515, PAL)
* [http://www.mikrocontroller.net/topic/37603 TV Bild mit AVR] und [http://www.mikrocontroller.net/topic/53141#413260 AVR) Videogenerator, 40x25 Zeichen, nur 60% CPU Auslastung] von Benedikt K. (Atmega8, PAL)
* [http://www.serasidis.gr/circuits/AVR_VGA/avr_vga.htm Simple VGA/Video Adapter] von Ibragimov Maxim Rafikovich (Atmega8, Atmega16..., PAL oder VGA)
* [http://www.rickard.gunee.com/projects/video/pic/howto.php PIC B&W Video] von Richart Gunee. Inkl. PONG und TETRIS Spiel (PIC16C84, PAL)
* [http://www.dtweed.com/circuitcellar/caj00161.htm#2833 TV Oscilloscope], [http://www.dtweed.com/circuitcellar/caj00150.htm#2670 AVR Video Generator] und [http://instruct1.cit.cornell.edu/courses/ee476/video/index.html Video Generation with Atmel AVR microcontrollers] von Bruce Land.
* [http://www.ulrichradig.de/home/index.php/avr/videotext AVR Videotext] und [http://www.ulrichradig.de/home/index.php/arm/pal_video ARM PAL Video] von Ulrich Radig.
* [http://www.cesr.ncsu.edu/agdean/stiglitz/ STIGLitz]: Efficiently Generating Video with an 8 bit MCU using Software Thread Integration (ATmega128, NTSC)
* [http://benryves.com/projects/tvtext tvText] is a library, that allows you to generate text display on a PAL TV using an ATmega168 running at 20MHz and two resistors to form a 2-bit DAC.
* [http://code.google.com/p/arduino-tvout/ arduino-tvout] - A composite video output library for AVR/Arduino. Output is NTSC or PAL at a resolution of 128x96 by default.
* [http://www.mikrocontroller.net/topic/53139 TV VIDEO BILD BAS Frequenzzähler DVM Atmega8 Assembler
] von Bernhard S.

=== Farbe ===

Es gibt mindestens drei Arten, wie man Farbbilder (RGB-Signale) auf einem TV-Monitor darstellen kann:

==== per RGB-Eingang ====

Der RGB-Eingang am Scart-Eingang ist die einfachste Art. Aber nicht bei jedem Scarteingang ist RGB auch belegt und man kann das Bild nicht mit dem Videorekorder aufzeichnen.

Weblinks:

* [http://www.mikrocontroller.net/topic/54562#421942 Einfache Grafikkarte mit 256x252 und 256 Farben für AVR] von Benedikt K. (Atmega8515 @ 16 MHz, PAL). Es werden die drei RGB-Signale und das Composite Sync Signal erzeugt, d.h. ggf. ist noch ein NTSC/PAL-Encoder notwendig.
* [http://www.electronicspit.com/video/ PAL/RGB 32x24 Zeichen mit 2x4bit Farben] von Eddy-B (ATMega32 @ 16 MHz, PAL). Auch hier werden 3 RGB-Signale und ein Composite Sync Signal erzeugt.
* [http://avga.prometheus4.com/ The AVGA project] - open source AVR based color video game development platform for single chip game console.

==== per Hardware-IC ====

Man kann fertige ICs benutzen, die RGB nach FBAS wandeln können, z. B. den AD724, allerdings sind diese ICs meist relativ teuer (20 Euro).

Weblinks:

* [http://instruct1.cit.cornell.edu/courses/ee476/FinalProjects/s2002/carlo/index.html Psychedelic Snake Spiel] von Carlo Soracco und Keith Sinclair. Zur RGB nach NTSC Umwandlung wird der IC [http://www.analog.com/en/prod/0,2877,AD724,00.html AD724 RGB to NTSC/PAL Encoder] von Analog Devices benutzt. (Atmega163, NTSC)
* The [http://belogic.com/uzebox/ Uzebox] is a retro-minimalist homebrew game console. Functions such as video sync generation, tile rendering and music mixing is done realtime by a background task so games can easily be developed in C. The final design contains only two chips: an ATmega644 and an [http://www.analog.com/en/digital-to-analog-converters/video-encoders/ad725/products/product.html AD725] RGB-to-NTSC(/PAL) converter.

==== per Software ====

Die Erzeugung des gesamten Videosignals per Software ist ''sehr'' zeitkritisch. Will man das vernünftig machen, dann sollte die CPU genügend Leistung haben.

Weblinks:

* [http://www.serasidis.gr/circuits/colour_bar_gen/colour_bar_gen.htm AVR PAL colour bar generator] von Serasidis Vasilis (AT90s2313 , PAL)
* [http://www.rickard.gunee.com/projects/video/sx/gamesys.php SX Games] von Richart Gunee ([http://www.parallax.com/sx/index.asp SX28], PAL). Hier gibt es auch viele weiterführende Links!
* [http://www.linusakesson.net/scene/phasor/index.php Phasor], like [http://www.linusakesson.net/scene/craft/index.php Craft], is a demo running on a custom minimalistic ATmega88-based demo platform. But it generates a composite video signal (PAL) instead of a VGA signal.
* [[PAL Testbildgenerator]] Ein ATMega32 mit 16MHz erzeugt ein statisches Testbild
* [http://homepages.ihug.com.au/~daz2002/tech/TP/index.html PM5544-Generator] mit ATmega88

==== per CPLD ====

Eine weitere Möglichkeit besteht darin, das FBAS-Signal mittels eines preiswerten programmierbaren Logikchips (CPLD) zu erzeugen. Da der Farbträger mittels DDS aus dem Systemtakt gewonnen wird, ist zur Vermeidung von Interferenzstörungen eine Tiefpassfilterung der erzeugten Signale notwendig.

Weblinks:

* [http://www.jcwolfram.de/projekte/vhdl/fbas_enc/main.php FBAS-Encoder]

==== per OnScreenDisplay IC ====

Alternativ kann man einen OSD IC benutzen. Diese verfügen meist über einen integrierten Zeichensatz, den man teilweise auch ändern kann. Meist sind diese S/W, einige Exoten sind mit Farbe, dafür dann meistens ohne eigenen Zeichensatz. Diese findet man meist in alten TVs oder Videorecordern.

* [http://www.maxim-ic.com/quick_view2.cfm/qv_pk/5516 Single-Channel Monochrome On-Screen Display with Integrated EEPROM MAX7456]
* [http://www.grautier.com/grautier/index.php?/archives/48-Eagle-LIBs.html Eagle lib MAX7456]
* [http://www.grautier.com/grautier/index.php?/archives/60-C2OSD-V1.0.html MAX7456 Schaltung + PIC16F ASM Beispiel]
* [http://www.mcselec.com/index2.php?option=com_forum&Itemid=59&page=viewtopic&t=5624&highlight=max7456 AVR Bascom beispiel]

[[Kategorie:Video]]

Benutzer Diskussion:Ingo w

2014-07-12T18:20:01Z

Kruemeltee: Die Seite wurde neu angelegt: „r?“

AVR Net-IO Bausatz von Pollin

2011-12-12T00:29:37Z

Kruemeltee: /* Simon Ks Webserver (uip-Stack) */

Hier steht eine Beschreibung des Pollin Bausatzes [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=NQ==&a=MTQ5OTgxOTk= AVR-NET-IO. Best.Nr. 810 058], oder als aufgebautes Fertigmodul, Best.Nr. 810 073.

Einige Features: Ethernet-Platine mit ATmega32 und Netzwerkcontroller ENC28J60. Die Platine verfügt über 8 digitale Ausgänge, 4 digitale und 4 ADC-Eingänge, welche alle über einen Netzwerkanschluss (TCP/IP) abgerufen bzw. geschaltet werden können.

[[Datei:AVR-NET-IO ADD-ON.JPG|thumb|right|400px|AVR-NET-IO (links) mit zusätzlicher SUB-D Anschlussplatine (rechts, nicht im Lieferumfang)und Add-On-Board (oben, mit aufgelötetem RFM12-433-Modul, beides nicht im Lieferumfang). Ebenso ist zusätzlich ein nicht im Lieferumfang enthaltener kleiner Kühlkörper auf einem der Spannungsregler montiert und die Schraubklemmen zur Stromversorgung wurden durch Buchsen ersetzt.]]

== Technische Daten ==

* Betriebsspannung 9 V AC/DC
* Stromaufnahme ca. 190 mA
* 8 digitale Ausgänge (0/5 V) [PC0-PC7 an J3]
* 4 digitale Eingänge (0/5 V) [PA0-PA3 an J3]
* 4 ADC-Eingänge (10 Bit) [PA4-PA7 an Schraubklemmen]
* LCD-Anschluss (HD44780 komp. Controller nötig) [PD2-7,PB0,PB3 an EXT]
* [[ENC28J60]]
* [http://www.atmel.com/dyn/Products/Product_card.asp?part_id=2014 ATmega32] Mikrocontroller

Maße (L×B×H): 108×76×22 mm.

== Hardware ==

Die Schaltung des AVR-NET-IO ist recht einfach:
* Ein ATmega32 Mikrocontroller enthält die gesamte Software
* Ein ENC28J60 Ethernet-Controller für das Senden und Empfangen von Ethernet Frames (MAC und PHY Ethernet Layer) ist über [[SPI]] mit dem ATmega32 verbunden
* Ein Ethernet RJ-45 MagJack TRJ 0011 BA NL von [http://www.trxcom.com/ Trxcom] mit eingebautem Übertrager und Anzeige-LEDs am ENC28J60.
* Ein MAX232 für die serielle Schnittstelle
* Zwei Spannungsregler, 5 V und 3,3 V
* "Hühnerfutter"

Fast alle I/O Pins des ATmega32 sind irgendwo auf Anschlüssen herausgeführt. Entweder auf dem SUB-D Stecker, dem EXT oder ISP Wannensteckern oder den blauen Anschlussklemmen. Eine Schutzbeschaltung gibt es nicht.

Die blauen Anschlussklemmen haben eine Nut und eine Feder mit denen man
sie zusammenstecken kann, dadurch ist das Anlöten wesentlich leichter
und sie stehen auch sauber in der Reihe.

=== Erweiterungsplatine ===

Seit Januar 2010 gibt es auch eine Erweiterungsplatine

[http://www.pollin.de/shop/dt/Nzg4OTgxOTk-/Bausaetze/Diverse/Bausatz_Add_on_fuer_AVR_NET_IO.html Add-on für AVR-NET-IO-Board Best.Nr. 810 112]

Diese Platine erweitert das NET-IO um:

* SD-Karten-Slot über SPI
* Display über PCF 8574
* Infrarot
* [[RFM12]] Funkmodul (nicht im Lieferumfang enthalten)

Ausserdem soll es die 3.3V Versorgung der Hauptplatine verbessern. Dazu sollte man einen 4,7 kOhm Widerstand parallel zu R2 schalten. Sonst beträgt die Ausgangsspannung nur ca. 2,8V. (Tipp aus dem u.g. Thread im Forum)

Um bei einem Neuaufbau parallele Widerstände zu vermeiden, sollten folgende Änderungen auf dem Addon-Board gemacht werden:
*R2 1,5kΩ ersetzen mit 2kΩ
*R3 1,8K ersetzen mit 3,3kΩ
*R19 470kΩ ersetzen zu 470Ω
*Q1 BC548 ersetzen durch BC327 oder BC328 (Hauptsache PNP! und mehr als 100mA)

Stand Feb. 2011: R2 wird mit 2,2kΩ und R3 wird mit 3,6kΩ ausgeliefert. Somit werden die 3,3 V richtig erzeugt. R19 hat 470Ω.
Der ISP-Anschluß ist nicht vollständig durchgeschleift, es besteht keine Verbindung der RESET-Leitung zwischen ISP und ISP1 (Abhilfe: Drahtbrücke einlöten, [http://www.mikrocontroller.net/topic/161354#1600385 Quelle]).

Stand Nov. 2011: bei mir ist die RESET-Leitung korrekt zw. ISP und ISP1 verbunden. Es gibt jetzt auch einen R24 (470Ohm) und R11 (1KOhm), der in der bei mir mitgelieferten Bauanleitung fehlt, in der zum Download (V1.1) angebotenen aber drin steht.
Es wird immer noch der falsche Q1 BC548C (NPN) mitgeliefert. Das Schaltsymbol für einen PNP ist richtig im Schaltplan gezeichnet.

Erste Erfahrungsberichte im Forum http://www.mikrocontroller.net/topic/161354

=== Hardware-Umbauten & -Verbesserungen ===

* Kühlkörper auf dem 7805
* MAX232 nach anfänglicher Konfiguration nicht bestücken um Strom zu sparen oder um zwei weitere I/O-Pins zu gewinnen
* 10µF-Elkos für MAX232N (C14-C17) durch 1µF ersetzen. Eine 10µF-Version für den MAX232 gibt es nicht. Die 10µF-Elkos können auch Ursache einer nicht funktionierenden RS232 sein.
** Laut Spezifikation sind auch mehr als 1µF erlaubt. Selbst Atmel verwendet beim STK500 10µF. Dies führt keinesfalls dazu, dass die RS232 nicht mehr funktioniert.
* Die IC-Fassungen aus "Pollins Resterampe" durch Fassungen mit gedrehten Kontakten ersetzen.
* ''Netz'' LED nicht bestücken oder größere Widerstände einlöten um Strom zu sparen (R3)
* Vorwiderstände der Ethernet-LEDs größer machen (z. B. verdoppeln) um Strom zu sparen (R6,R7)
* Linear-Spannungsregler ersetzen
* Kondensator an AREF-Pin des ATmega32 (ATmega32 Datenblatt) (100nF gegen Masse)
* Kondensator an den RESET-Pin des ATmega32 ([http://www.atmel.com/dyn/resources/prod_documents/doc2521.pdf Atmel Application Note AVR042: AVR Hardware Design Considerations]) Wenn man diese Quelle genauer liest, ist das aber eher unnötig. - Kondensator bei selbstbau-ISP empfehlenswert.
* Umbau auf 3,3 V:
** Ersatz der Spannungsregler durch einen einzigen 3,3 V Regler
** Anpassen (verkleinern) des LED-Vorwiderstands R3 für 3,3 Volt Betrieb
** Reduktion der Taktfrequenz (Austausch von Q2) auf den bei 3,3V erlaubten Bereich des ATmega32 ( ATmega32(L) 3.3V /8.0 Mhz Takt )
** Ersatz des MAX232 durch einen MAX3232
[[Bild:POWER.JPG|thumb|400px|5V Stromversorgung über USB Kabel, ohne 5 V Spannungsregler und Gleichrichterdioden, Vorsicht: kein Verpolungsschutz! ]]
* ATmega32 vom ENC28J60 takten (OSC2)
* Betrieb mit Gleichspannung:
** Dioden D2 und D5 durch Drahtbrücken ersetzen, D1 und D4 nicht bestücken (komplette Entfernung des Brückengleichrichters, beinhaltet Verlust des Verpolungsschutzes)
** Diode D2 bestücken, D5 durch Drahtbrücke ersetzen, D1 und D4 nicht bestücken (Brückengleichrichter durch Verpolungsschutze ersetzen)
*** ??? Ist dies nicht kontraproduktiv? Bei mir wurde durch D2-Bestückung die Eingangsspannung von ca. 5,2 V am LM317T auf ca. 4,6 V gedrückt, so dass am ENC28J60 nur ca. 2,6 V ankamen (außerhalb der lt. Datenblatt "Operating voltage range of 3.14V to 3.45V"). Man müsste also ein geregeltes Netzteil mit ca. 5,5 V anschließen um 5 und 3,3 V zu erzielen. Dann lieber den Verpolungsschutz durch andere Maßnahmen sicherstellen.
** Beim Betrieb von USB beachten, dass USB-Spezifikation keinesfalls 5V garantiert, sondern Spannung bis runter 4.4V erlaubt und dann u.U. durch den LM317 nicht mehr genügend Spannung am ENC anliegt. Das äußert sich so, dass zwar der Atmega einwandfrei funktioniert, die Ethernet-Kommunikation aber nicht oder nur sehr sporadisch.
* Ersatz des ATmega32 durch einen ATmega644 mit mehr FLASH-Speicher.
* 100nF über alle drei IC Störunterdrückung zusätzlich bestücken

== Inbetriebnahme der Originalsoftware ==
=== Einleitung ===

Die bei Auslieferung (Stand September 2008) in den ATmega32 gebrannte Firmware stellt sich manchmal recht zickig an. Es scheint dann die Netzwerk-Schnittstelle, ggf. auch die seriell Schnittstelle, nicht zu funktionieren. Falls es Probleme geben sollte, sollte man erst einmal einen Firmwareupdate versuchen. Dies geschieht über die serielle Schnittstelle mittels des Programmes NetServer (aktuelle Version 1.03, Februar 2010), die dem Bausatz beiliegt.

Falls die serielle Schnittstelle ebenfalls nicht zugänglich ist, kann mit den im folgenden beschriebenen Schritten die Inbetriebnahme der Software möglich sein. Dazu benötigt man:

* Einen Windows-PC mit Ethernet-Schnittstelle und RS232-Schnittstelle (ein Prolific RS232-USB Konverter funktioniert)
* Entweder
**zwei normale (''straight through'') Ethernet-Kabel und einen Ethernet Switch/Hub, oder
**ein gekreuztes(''cross over'') Ethernet-Kabel
* Einen AVR Programmer (Hardware und Software). Zum Beispiel einen [[AVR Dragon]] oder [[STK500]] mit [[AVR Studio]] oder das [[Pollin ATMEL Evaluations-Board]] und [[avrdude]].
* Die [http://www.pollin.de/shop/ds/MTQ5OTgxOTk-.html Pollin NetServer Software], Version 1.03 (oder neuer)

=== Gelieferten ATmega32 richtig einstellen ===
[[image:fuse_bits_avr_studio.jpg|thumb|right|250px|Einstellungen der Fuse-Bits mittels AVR Studio 4]]
Die Fuses der gelieferten ATmega32s scheinen nicht immer mit den im Handbuch auf Seite 12 als erforderlich angegebenen Fuse-Einstellungen übereinzustimmen.

Dies kann man mittels eines Programmers ändern. LFuse = 0xBF, HFuse = 0xD2. Das genaue Vorgehen hängt dabei vom verwendeten Programmer ab. Bei der Gelegenheit kann man ebenfalls eine Sicherheitskopie des ursprünglichen Flash-Inhalts und des EEPROMs anfertigen. Das EEPROM scheint die MAC-Adresse des Ethernet-Ports zu enthalten.

Entgegen der Spezifikation im Handbuch von Pollin sollten die '''HFuses auf 0xC2''' gesetzt werden, d. h. CKOPT-Fuse programmiert (dies ist in der Software Version 1.03 bereits vollzogen). Das sorgt für einen stabilen Betrieb des AVR-Oszillators im "full rail-to-rail swing"-Mode bei 16 MHz. Atmel garantiert ansonsten nur stabilen Betrieb bis 8 MHz. Siehe ATmega32-Datenblatt, Kapitel 8.4, Crystal Oscillator.
{{Absatz}}

==== Funktionsfähige Konfiguration - AVR-Prog ====

[[Bild:Avrprog.png|thumb|right|250px]]
Benutzer von AVR-Prog können die nachfolgenden Einstellungen für die Lock- und Fuse-Bits verwenden. Hierbei handelt es sich um die ausgelesenen Einstellungen eines funktionsfähigen Controllers. Allerdings sollte, laut Handbuch des AVR-NET-IO-Boards, das Fuse-Bit EESAVE eigentlich gesetzt sein.

Alternativ kann auch per avrdude die Einstellung getroffen werden:
avrdude -c stk500v2 -pm32 -U lfuse:w:0xBF:m
und
avrdude -c stk500v2 -pm32 -U hfuse:w:0xC2:m

Anschließend muß noch der Bootloader und die Firmware aktualisiert werden (siehe Handbuch AVR-NET-IO-Board Seite 12 Punkt 3).

=== PC Konfiguration ===

==== PC normalerweise nicht im 192.168.0.0/24 Subnetz ====

Betreibt man den PC nicht im 192.168.0.0/24 Subnetz, muss er wie folgt umkonfiguriert werden, oder die IP Adresse des Boards wird entsprechend angepasst. ( Siehe Handbuch Seite 14ff. Das ist meist sinnvoller und auch einfacher. )

Den PC vom normalen Netzwerk abstecken[1]. Zur Umkonfiguration dazu bei Windows XP in der Systemsteuerung ''Netzwerkverbindungen'' aufrufen und die lokale ''LAN-Verbindung'' markieren. Dann in der rechten Leiste ''Einstellungen dieser Verbindung ändern'' aufrufen.

Es erscheint der Dialog ''Eigenschaften von <Verbindungsname>''. In der Liste im Dialog zu ''Internetprotokoll (TCP/IP)'' gehen. Ein Doppelklick auf den Eintrag öffnet den ''Eigenschaften von Internetprotokoll (TCP/IP)'' Dialog.

In diesem Dialog ''Folgende IP-Adresse verwenden:'' auswählen und zum Beispiel

IP-Adresse: '''192.168.0.100''' 
Subnetzmaske: '''255.255.255.0''' 
Standardgateway: '''192.168.0.1'''

eingeben.

Anmerkung von bitman:
[1] Dies ist spätestens ab Windows XP nicht mehr notwendig, wenn das Netz 192.168.0.0/24 noch frei ist. Dann kann man einfach den Client ''zusätzlich'' in diesem Netzwerk zusätzlich einbinden über Einstellungen/Netzwerkverbindungen/Lanverbindung/Eigenschaften/TCP-IP/Eigenschaften/Erweitert/IP-Adresse hinzufügen. Es werden dann eben mehrere IP-Adressen an den NIC gebunden.

Alle geöffneten Dialoge nacheinander mit OK schließen.

Alternativ bietet sich das Umprogrammieren des Boards über die serielle Schnittstelle an. Die Werte für IP-Adresse, Netzmaske und Standard-Gateway werden mit den dokumentierten SETxx-Befehlen geändert, das Board neu gestartet und ans vorhandene Netzwerk gesteckt.

Im EEPROM sind folgende Werte vorprogrammiert: 
3EE - 3F3 MAC-ADRESSE 
3F4 - 3F7 GATEWAY 
3F8 - 3FC NETMASK 
3FD - 3FF IP-ADRESSE 

==== PC bereits im 192.168.0.0/24 Subnetz ====

In diesem Fall muss man prüfen, ob die IP-Adresse 192.168.0.90 bereits im Subnetz verwendet wird. Ist dies der Fall, muss das verwendete Gerät mit dieser IP vorübergehend aus dem Subnetz entfernt werden. Es sei denn, dabei handelt es sich um den PC. In diesem Fall muss er wie zuvor umkonfiguriert werden. Ansonsten kann der unverändert im Netz verbleiben.

Dem AVR-NET-IO gibt man eine neue, zuvor unbenutzte Adresse (siehe unten). Dann kann das abgekoppelte Gerät wieder angeschlossen werden, beziehungsweise der PC zurückkonfiguriert werden.

=== AVR-NET-IO anschließen ===

Musste man den PC umkonfigurieren, so werden jetzt nur der PC und der AVR-NET-IO über Ethernet miteinander verbunden. Je nach Ethernet-Kabel benötigt man dazu einen Switch/Hub oder nicht.

Musste man den PC nicht umkonfigurieren, so kann man den AVR-NET-IO wie einen normalen Rechner an das vorhandenen Netz anschließen.

Zusätzlich schließt man die serielle Schnittstelle des AVR-NET-IO an den PC an.

=== Firmware 1.03 einspielen ===

Laut Handbuch sollte der AVR-NET-IO jetzt über Ethernet funktionieren. Ebenso sollte er über die serielle Schnittstelle und ein Terminalprogramm konfigurierbar sein. Beides ist offensichtlich im Auslieferungszustand selten der Fall.

Auch wenn sich Pollins NetServer Software nicht mit dem AVR-NET-IO verbinden lässt, so ist sie jedoch in der Lage eine neue Firmware 1.03 einzuspielen. Das Vorgehen ist im Handbuch auf Seite 12 beschrieben. NetServer präsentiert dabei ein paar einfache Anweisungen denen man folgen sollte.

Wenn sich nach dem scheinbar erfolgreichem Einspielen der Firmware, später nichts tut, so sollte die Firmware mit gesetztem "FailSafe" in der mitgelieferten NetServer-Software nochmals Eingespielt werden.

=== Abschluss ===

Jetzt sollte sich die NetServer Software mit dem AVR-NET-IO über Ethernet verbinden lassen. Dies macht es wiederum möglich, den AVR-NET-IO mit einer anderen IP-Adresse zu versehen. Will man den AVR-NET-IO in einem anderen Subnetz betreiben kann man dies jetzt einstellen.

Nachdem man die IP-Adresse neu eingestellt hat, muss man den PC zurückkonfigurieren und kann dann sowohl den AVR-NET-IO und den PC zusammen betreiben.

== Bekannte Fehler ==

Siehe auch [[#Hardware-Umbauten_.26_-Verbesserungen|Hardware-Umbauten und Verbesserungen]] 
Käufer berichten von fehlenden Bauteilen im Bausatz (Wannenstecker, Widerstände, Kondensatoren, Induktivitäten). Für Reklamationen: [https://www.pollin.de/shop/kontakt_service/reklamation.html]

* Die Stückliste auf Seite 4 in den Anleitung mit den Versionsangaben
** ''Stand 20.08.2008, kloiber, #1100, wpe'' (gedruckt im Bausatz)
** ''Stand 20.08.2008, cd, #all, wpe'' (auf der CD)
:ist falsch. Pollin legt dem Bausatz irgendwann ab September 2008 einen gedruckten Korrekturzettel bei. Die Online-Version der Anleitung ist korrigiert.
* Im Schaltplan auf Seite 7 in den Anleitungen mit den Versionen
** ''Stand 20.08.2008, kloiber, #1100, wpe'' (gedruckt im Bausatz)
** ''Stand 20.08.2008, cd, #all, wpe'' (auf der CD)
** ''Stand 03.09.2008, online, #all, wpe'' (Online)
:ist eine 25-polige SUB-D Buchse gezeichnet. Geliefert wird und in der Stückliste verzeichnet ist ein Stecker.

* Die September 2008 ausgelieferte Firmware im ATmega32 funktioniert bei vielen nicht und muss erst upgedatet werden (siehe [[#Inbetriebnahme der Originalsoftware|Inbetriebnahme der Originalsoftware]])

* Im Flash der gelieferten AVR ist anders als beschrieben nur der Bootloader enthalten, die eigentliche Firmware muss erst mit Hilfe der Updatefunktion geladen werden. Wenn zusätzlich auch die Fuses falsch gebrannt sind, dann funktioniert das Update nicht, auch wenn das PC Programm was anderes behauptet.

* Die Fuse-Einstellungen des ausgelieferten ATmega32 entspricht nicht der Anleitung (siehe [[#Inbetriebnahme der Originalsoftware|Inbetriebnahme der Originalsoftware]])

* Bausatz, gekauft am 27.10.08, Anleitungsversion 19.09.08, ohne Probleme oder erkennbare Fehler zusammengebaut und in Betrieb genommen.

* Bausatz gekauft 29.09.2008, Pinbelegung des 25 poligen D-Sub "Anschlusses" stimmt nicht mit der Anleitung überein. Der Aufdruck auf der Platine ist falsch. Pin1 <-> Pin13, Pin2 <-> Pin12 usw. Setzt man den D-Sub Stecker ein, so sind dessen Pinnummern korrekt. Bei einem Bausatz gekauft 10/2010 ist dies ebenfalls noch der Fall.

* 3 Bausätze Anf. Oktober 2008 gekauft, bei einem waren 2 LM317 dabei, dafür fehlte der 7805 - aus der Bastelkiste ersetzt. Alle haben jedoch auf Anhieb funktioniert

* Bausatz gekauft Ende Januar 2009. Die Lock-Bits (u.a. für PonyProg2000) werden falsch beschrieben. Die in Klammern aufgeführten Werte stimmen bei einem Bit nicht. Die Texte "Programmiert/Unprogrammiert" hingegen schon. Bei den Bauteilen gab es 4 Kondensatoren mit der Aufschrift "220", ich habe diese durch welche mit 22p ersetzt, da ich nicht sicher war ob wirklich 22p geliefert wurden. Dafür wurden statt einem zwei 7805 und statt einem mindestens vier LM317 mitgeliefert.

* Bausatz geliefert 22.4.2009. Alles vollständig, zusammengebaut, läuft. Software-Version 1.03. Für den oben schon genannten Steckverbinder wurde eine Buchse geliefert. Allerdings stimmen die PIN-Nummern im Schaltplan nicht mit den PIN-Nummern auf der Buchse überein (sie sind gespiegelt), daher liefen die Test-LEDs zunächst nicht.

* Bausatz geliefert 11.7.2009. Spannungsregler LM317T fehlt, grüne statt roter LED. Ein Kondensator 22pF zu viel. LM317T wurde auf Anfrage kostenlos nachgeliefert (27.7.). Inbetriebnahme problemlos.

* Bausatz geliefert 24.7.2009. Ein Quarz 16MHz zu viel, ebenfalls grüne statt rote LED.

* Bausatz geliefert 20.08.2009. Ein Kondensator 22pF zuviel und grüne statt rote LED.

* Bausatz Juli '09 gekauft, grüne statt rote LED

* Bausatz 25.09.09 geliefert, grüne Betriebs-LED, ein ELKO zuviel, Fehler 1µF am MAX232 statt 100nF behoben, richtiger C wird mitgeliefert, Aufbau komplett nach Pollin Anleitung durchgeführt, auf Anhieb fehlerfrei!

* Bausatz 17.10.09 geliefert, grüne Betriebs-LED, zwei 100nF Kondensatoren zu wenig. Aufbau und Inbetriebnahme problemlos.

* Bausatz 21.10.09 gekauft, grüne Betriebs-LED. Aufbau problemlos, RS232 läuft nicht. LAN läuft

* Bausatz Nov. 09 gekauft, grüne LED, alles o.k.

* Bausatz Nov. 09 gekauft, grüne LED, ENC28J60, MAX232 und ATmega32 fehlen, Nachlieferung nach einer Woche

*Bausatz Nov. 09 gekauft,Bauteile komplett.Verbindungsaufbau Seriell klappt erst nach mehreren Versuchen.Problem gelöst:Spannung an MAX und Mega zu niedrig

* Bausatz Dez. 09 gekauft, grüne LED, 100µF Kondensator fehlt, alles o.k.

* Bausatz August 09 gekauft, alle teile da nach Einstellen der fusebits lief alles perfekt

* Bausatz Okt. 09 gekauft, ein 100nF Kondensator und 25MHz Quarz fehlten ... hab beim lokalen Elektronikhändler keinen 25Mhz Grundton Quarz sondern nur im 3. Oberton bekommen aber mit R2.2k parallel zum Quarz schwingt er in der Schaltung schön bei 25Mhz. Mit 1µF am MAX232 funktioniert jetzt auch die RS232.

* 2x Bausatz Feb. 10 gekauft, bei beiden fehlten 7805, L1+L2 je 100µH sowie 4x falscher Wert Kondensator an Max232 vorhanden. Fehlende Bauteile nachgelötet und Funktion getestet. Hat alles einwandfrei funktioniert!!!

* Bausatz März. 10 gekauft, RS232 Printbuchse fehlt, dafür 1x 10pol Wannenstecker zuviel. Grüne LED statt Rot. Funktioniert ansonsten einwandfrei.

* Bausatz Jan. 10 gekauft, gelbe LED statt rot, C14...C17: 10µF, weder seriell noch via Ethernet Konnektivität. Nach Austausch von C14-C17 gegen 1µF, wenigstens serielle Kontaktaufnahme möglich, kein Ethernet auch nach Flash von 1.03 mit NetServer.

* Bausatz Feb. 10 gekauft, Spannungsregler LM317T fehlte

* Bausatz März 10 gekauft, gelbe statt rote LED geliefert, aber Aufbau und inbetriebnahme lt. Handbuch ohne Probleme

* Bausatz März 10 gekauft und gelbe statt rote LED geliefert, funzt wunderbar gemäß Anleitung

* Fertig gelötete Platine gekauft. µC war falsch im Sockel.

* Bausatz April 10 gekauft und gelbe statt rote LED geliefert, ADM232LJN statt MAX232 - Funktion erst nach Ersetzung des ADM durch nen MAX

* Bausatz April 10 gekauft und gelbe statt rote LED geliefert, ADM232LJN statt MAX232 - funktionierte sofort auch mit dem ADM232LJN.

* Bausatz April 10 gekauft wurde mit grüner statt roter LED Ausgeliefert

* Bausatz Juni 10 gekauft: wurde mit grüner statt roter Netz-LED ausgeliefert, 2x 22pF Kerko zuviel

* Bausatz August 10 gekauft: komplett und sofort funktioniert
* Bausatz Juli 10 gekauft: 2 Quarze mit 16 MHz geliefert, statt 1x 16MHz und 1x25MHz.
* Bausatz September 10 gekauft: hat sofort funktioniert. 1x 3,3k und 1x 10k Widerstand zuviel. Statt 100nF Kondensatoren wurden 1µF geliefert -> Platzprobleme auf der Platine durch grössere Bauform. LED grün.
* Bausatz Oktober 6 gekauft: alles funktioniert. LED grün statt rot.

* Fertigmodul Oktober 10 gekauft: Auf Anhieb alles funktioniert!
* Bausatz Oktober 10 gekauft: komplett und sofort funktioniert

* Bausatz November 10 gekauft: komplett und sofort funktioniert (sogar mit der neusten Pollin Firmware 1.03 schon drauf) LED grün statt rot.

* Bausatz November 10 gekauft. Nach Bezug neuer Feinst-Lötspitzen konnte ich ihn dann auch zusammenlöten. Es hat sofort alles funktioniert, obwohl ich nur 12V bzw. 9V Gleichspannung zur Verfügung hatte, und nicht sicher war, wieviel die Komponenten wirklich benötigen. Der Regler wird auch bei 9V Gleichspannungsversorgung noch sehr warm. Da muss auf jeden Fall ein Kühlkörper dran! Ich habe auch eine grüne LED bekommen, ist mir aber wurscht :-)

* Bausatz Dezember 10 gekauft: komplett und funktionierte sofort. Firmware 1.03, grüne LED (Ein Quarz und ein IC-Sockel zu viel)

*Bausatz Januar 2011 gekauft: nur genau die richtige Anzahl Teile dabei, Firmware 1.03, grüne LED, ging auf Anhieb

* 2x Bausatz Januar 2011 gekauft: beide grüne LED, und 1x doppelter Satz Jumper/Stiftleiste, 22PF und Anschlussklemmen. Rest vollständig und beide haben sofort nach zusammenbau funktioniert.

* Februar 2011: AVR-NET-IO: die Diode D5 fehlt, 10 µF gegen 1 µF für MAX232 getauscht, Flash im ATmega32 war programmiert, passende IP-Adr über serielle Schnittstelle eingestellt; ADD-ON: für R1 war 22Ω statt 0,2Ω beigelegt, durch richtigen ersetzt, Beschreibung der LED Bestückung mangelhaft / oe1smc

* Februar 2011: AVR-NET-IO: 1 Diode zuviel, 2 Spulen fehlen, LED grün. Die fehlenden Spulen wurden durch welche aus der Bastelkiste ersetzt - funktioniert. Der 7805 bekam einen kleinen Kühlkörper spendiert.

* Februar 2011: AVR-NET-IO: 2x 10k Widerstände fehlen. Dafür eine Diode zu viel.

* Ende Februar 2011: Zwei Bausaetze an jeweils zwei Adressen, alles in Ordnung.

* Ende März 2011: 2x 25 Mhz Quarz statt 1x16 u. 1x25 Mhz. LED fehlt. Bausatz funktioniert nach Tausch des Quarz den mir mein Freund oe9rsv aus seinem Fundus spendiert hat. Danke auch für die Hilfe beim Fehler suchen.

* Mitte 2010 gekauft: 1x 100nF fehlt

* Mitte Juni 2011: Beide Quarze fehlen und beide Spannungsregler fehlen, Pollin wollte, dass ich das ganze Paket zurückschicke für einen Austausch. Ein 51Ω zu viel. 16Mhz im Handel und 25Mhz vom alten Mobo ausgelötet. Läuft wunderbar.

* Anfang Juni 2011: Beide Quarze fehlen und beide Spannungsregler fehlen, nach kurzer Mail an Pollin (leider ohne Antwort) wurden diese nach ca. 1 Woche in einem Brief nachgeliefert.

* August 2011: alles 1a...
* August 2011: Platine fehlte -> in Nachlieferung
* 30 August 2011: alles 1a...
* 06 Sep. 2011: alles 1a...
* August 2011: 6 Stück bestellt, bei einem haben die 100nF Kondensatoren gefehlt, bei einem zwei LM317 statt 7805 und LM317. Angerufen, 3 Tage später Nachlieferung erhalten.
* Nov. 2011: '''Net_IO''' vollständig. Einspielen der Firmware 1.03 war erforderlich. Bei '''Add-On''' immer noch falscher Q1 BC548 (NPN) in Stückliste und Lieferung. BC327-40 oder BC328-40 (PNP) nachgefordert. R11 und R24 mitgeliefert entsprechend Beschreibung V1.1 von Pollin's Download. Beiliegende Beschreibung war älter, ohne diese Widerstände.

* Ende Nov.2011, alle Teile dabei, Firmware war drauf, sofort funktioniert.

== Andere Software für den Client-PC ==
=== NetIOLib ===

In C# geschriebene Bibliothek zur Ansteuerung der Platine im Orginalzustand. Inkl. Beispielsoftware und Quellcode (GNU GPL)

DLL: [http://www.tware.org/downloads/NetIOLib_dll.zip Download-Link]
Source: [http://www.tware.org/downloads/NetIOLib_src.zip Download-Link]

=== ControlIO ===
Einfache Bibliothek zur Ansteuerung mit Originalfirmware.
http://www.mikrocontroller.net/topic/149695

=== JAVA Lib ===
Einfache Java-Bibliothek zur Ansteuerung mit Originalfirmware.
http://son.ffdf-clan.de/?path=forumsthread&threadid=611

=== App NetIO ===
Frei verfügbare App für Windows Mobile zur Ansteuerung mit der Orginalsoftware. Das HTC HD2 wird damit zur Fernsteuerung für das AVR Net-IO Board.
http://www.heesch.net/netio.aspx

=== PHP ===
PHP Klasse zur Ansteuerung mit der Originalfirmware. (Opensource Lizenz)
http://blog.coldtobi.de/1_coldtobis_blog/archive/298_pollin_net-io_php_library.html

PHP Funktionen zum Ansteuern der Originalfirmware. (Free for All Lizenz)
http://defcon-cc.dyndns.org/projects/mikrocontroller/netio.php

=== NET-IO Control ===
Eine Application für das Android Betriebssystem zur Steuerung des AVR Net-IO Boards

[[Datei:NET-IO-Control.png|200px]]

Team: [http://elektronik2000.de/ E2000-Team]

=== iPhone ===
==== NetIO ====
Schöne iPhone Fernbedienung für das Board. Konfigurierbar über eine JSON Datei. (Senden, Auslesen, Makros) 
http://itunes.apple.com/app/netio/id464924297?mt=8

Hinweis: Man findet es unter "NetIO" im AppStore, im Icon selbst und in iTunes wird es als "Controller" angezeigt. 
Den JSON (JavaScriptObjectNotation) Code kann man im [http://jsonlint.com/ JSONLint Validator] prüfen. 
Die Grafikausgabe der "Buttons" kann man mit [http://netio.davideickhoff.de/renderjson NetIO JSON Renderer] vorher am PC überprüfen.
==== AVR NetIO ====
Mit der [http://itunes.apple.com/de/app/avr-net-io/id460991760?mt=8 iPhone App AVR-Net-IO] kann das Board ferngesteuert werden. Die Fernsteuerung umfasst in der Version 1.1 folgende Funktionen: <ul>
<li>ADC-Werte zyklisch auslesen und darstellen</li>
<li>Digital-Inputs zyklisch darstellen</li>
<li>Digital-Outputs können über Buttons geschaltet werden. Die Werte der Digital-Outputs werden zuerst ausgelesen und zeigen den zuletzt gesetzten Wert an.</li>
<li>Terminal-Modus: Hier können beliebige AVR-Net-IO-Befehle eingegeben werden. Das Ergebnis wird 1:1 angezeigt, wie es vom Board kommt. Hilfreich für Tests bei Eigenentwicklungen und Konfigurationen.</li>
</ul>
 
Mehr Infos gibt's dazu von den Entwicklern auf [http://www.facebook.com/pages/AVR-Net-IO/187799687958255?ref=nf AVR-net-IO Facebook-Page] oder direkt auf deren Homepage [http://www.ondics.de/apps/1001/ Homepage].
 
Hinweis: MIt der aktuellen Version 1.1 gibt es noch bei manchen Boards Probleme beim auslesen und anzeigen der ADC- und Digital-Werte. Das Terminal funzt problemlos. Die Entwickler kümmern sich gerade drum und haben einen baldigen Update versprochen.
 

=== E2000 - Logik ===

[[Datei:E2000-Logik-Bedienoberflaeche.jpg|500px|rechts]]

Anwenderfreundliche Logik-Software vom Elektronik2000.de zur Steuerung des AVR-NET-IO über den Computer oder durch ein Firmware-Update auch autark.

'''Version 2.0a6''' beinhaltet eine Firmware, durch die das NET-IO mit einem Firmwareupdate in einen autarken Betrieb versetzt werden kann. Dazu ist ein ATMega644 notwendig. Durch diese Erweiterung ist es möglich, eine Logikschaltung in das Board zu schreiben, welche das Board dann simuliert. Es unterstützt außerdem ein Webinterface, eine TelNet-Schnittstelle und eine Live-View-Ansicht mit der es möglich ist, live zu sehen, wie der Status des Boards zu einem bestimmten Zeitpunkt ist. Die aktuelle Systemzeit wird aus dem Internet ermittelt.

Durch ein Erweiterungsboard von Elektronik2000.de ist es in '''Zukunft''' möglich, das Board ohne Internet laufen zu lassen durch eine RTC (RealTimeClock). Auf dieser Erweiterung wird auch ein EEPROM integriert sein, um Firmware-Updates über Netzwerk einzuspielen, damit kein direkter Eingriff in die Hardware notwendig ist. Diese Erweiterung bietet außerdem die Anbindung an das E2000-Bus-System.

Das Designen von Schaltaufgaben wird in diesem Programm grafisch dargestellt. Außerdem besitzt die Software (in der Version für die Pollin Firmware) einen Kennlinienschreiber und ein Webinterface.

Team: [http://www.elektronik2000.de E2000-Team]

== Andere Software statt der Originalsoftware von Pollin ==

Die Umrüstung auf einen Webserver durch Austausch der Software (und ev. des ATmega32) bietet sich an. Kleiner Hinweis dabei: wenn zum Flashen ein ISP-Adapter verwendet wird, diesen unbedingt vor dem Start der neuen Software abziehen! Der ISP arbeitet nämlich über dieselbe SPI-Schnittstelle über die auch der ENC28J60 angesteuert wird. Ein eventuell noch angeschlossener, wenn auch passiver ISP-Adapter stört diese Kommunikation, d.h. das Programm an sich scheint zu laufen, aber die Ethernet-Schnittstelle funktioniert nicht.

=== Bascom Version von Hütti ===

(Quelle: http://bascom-forum.de/index.php/topic,1781.45.html )
dort am Ende der Seite.

=== Ben's Bascom Quellcode ===

(Quelle: http://members.home.nl/bzijlstra/software/examples/enc28j60.htm )

Muss aber für Bascom 1.11.9.3 angepasst werden, siehe Code von Hütti !

=== U. Radigs Webserver ===

Angepasster Sourcecode von U.Radig: http://www.mikrocontroller.net/attachment/40027/Webserver_MEGA32.hex
oder selbst anpassen:
Ändere im File ENC28J60.H
#define ENC28J60_PIN_SS 3
#define ENC28J60_PIN_CS 4
(Quelle: http://www.mikrocontroller.net/topic/109988#988386)

Temporären Dateien (*.d, *,lst,*.o) vorher im Verzeichnis löschen ''make clean'', damit neu compiliert wird.

IP: 192.168.0.99 
User: admin 
Pass: uli1 

Den orginal SourceCode gibt's übrigens hier:http://www.ulrichradig.de/home/index.php/avr/eth_m32_ex

Bei den Fuses BOOTRST ausschalten, da die Software keinen Bootloader enthält.

Wer gerne als Link-LED die grüne nutzen möchte
(U.Radig-Source)

enc28j60.c Zeile 150

"enc28j60_write_phy(ENC28J60_PHY_PHLCON, 0x347A)

Wert 0x347A in 0x374A ändern

(Quelle: http://www.mikrocontroller.net/topic/109988#994943)

IP: 192.168.1.90 
User: admin 
Pass: tim 
Test: http://beitz-online.dyndns.org 
Test: http://pieper-online.dyndns.org 

Weiterentwicklung des Radig-Codes von RoBue: 
- 1-Wire-Unterstützung (Anschlus an PORTA7) 
- PORTA0-3 digitaler Eingang (ein/aus) 
- PORTA4-6 analoger Eingang (0 - 1023) 
- LCD an PORTC 
- Schalten in Abhängigkeit von Temperatur und analogem Wert 
- (Teilweise) Administration über Weboberfläche 
- Erweiterung des cmd-Befehlsatzes für telnet/rs232 
Gedacht ist der Einsatz des AVR-NET-IO-Bausatzes für Heizungs- oder Haussteuerung) 

Test: http://avrboard.eluhost.de/ 

(Quelle: 
http://www.mikrocontroller.net/attachment/43307/AVR-NET-IO_RoBue_V1.3.zip 
http://www.mikrocontroller.net/attachment/44569/AVR-NET-IO_RoBue_V1.4.zip 
http://www.mikrocontroller.net/attachment/46720/AVR-NET-IO_RoBue_1.5-final_hoffentlich_.zip)

Bei der Ver 1.5 sind die Ports PD2+3 fürs 4bit LCD (Ext.) vertauscht ! Gruß B.P

=== Simon Ks Webserver (uip-Stack) ===
Angepasster Sourcecode von Simon K: http://www.mikrocontroller.net/attachment/39939/uWebSrv.zip
IP: 192.168.0.93:8080 
Um diesen Code mit einem Atmega1284P verwenden zu können, muss in der main.c in Zeile 38, "TIMSK" durch "TIMSK1" ersetzt werden.
Die Fusebits für den Atmega1284p ohne Bootloader sind:
lfuse=0xFF, hfuse=0xD9, efuse=0xFF

=== Ethersex Server ===

http://www.ethersex.de - Einfach für atmega32 compilieren und funktioniert.

Oder
[http://www.ethersex.de/firmware-builder/list.cgi hier] ein Firmware Image passend für das Pollin Net-IO mit eingebautem Webserver und Beispieldateien im Flash bauen lassen und flashen (firmware-builder). Einfacher geht´s nimmer. :-)

=== Etherrape Server ===

http://www.lochraster.org/etherrape/

ist in jedem Fall hier auch zu erwähnen zumal es sich beim etherrape um das Ursprungsprojekt von ethersex handelt.
Es scheint aber bei der Weiterentwicklung wenig zu passieren.
Ausführliche Dokumentation findet sich unter http://wiki.lochraster.org/wiki/Etherrape

=== Mini SRCP Server (kommerziell, Closed-Source)===

Damit wird die Platine zu einer Modellbahnsteuerung, die
über das Netzwerkprotokoll SRCP mit verschiedenen Programmen
gesteuert werden kann.

[http://www.7soft.de/de/mini_srcp_server/index.html Infoseite] zur Hardware
und das zugrundeliegende [http://www.der-moba.de/index.php/Digitalprojekt Digitalprojekt].

=== AvrArtNode ===

Hiermit kann die Platine zu einem Art-Net Node werden, mit dem sich ein DMX-Universe über Ethernet übertragen lässt. Basiert auf den Quellen von Ulrich Radig.

Dokumentation: [http://www.dmxcontrol.de/wiki/Art-Net-Node_f%C3%BCr_25_Euro Art-Net-Node für 25 Euro]

=== Webserver von G. Menke ===

Ein Webserver (basierend auf den Sourcen von U. Radig), der so angepasst ist, dass alle Ein- und Ausgänge wie bei der originalen Pollin-Software genutzt werden können (8xDIGOUT, 4xDIGIN, 4xADIN). Der Webserver kann daher direkt auf das Net-IO geladen werden. Im ZIP-File sind ein ReadMe und alle C-Sourcen enthalten. Download:
[http://gm.stream-center.de/webserver/ Webserver mit passender IO]

=== OpenMCP ===

Tolles Projekt, welches viele Features bietet und stabil läuft. Hervorzuheben ist die Übersichtlichkeit der Programmteile/Module und die vielleicht nicht ganz komplette Dokumentation. Man merkt das viel Arbeit und Liebe in diesen Projekt steckt. Herausgekommen ist dabei eine einfach zu handhabende Entwicklungsumgebung. Anfänger können, dank des gut durchdachten CGI-System welches sich um alle wichtigen Sachen kümmert, leicht eigene CGI implementieren. Alle Ausgaben erfolgen nur mit printf über die Standardausgabe und werden automatisch richtig per Netzwerk übertragen, dadurch ist es auch für den Anfänger recht gut geeignet, da man sich nicht mit der Netzwerkprogrammierung auseinander setzen muss.

Die Software belegt im Moment (Stand Juli 2010) ca. 55 Kb im Flash, so dass man das Board mit einem grösseren µC (z.B. ATMega644) aufrüsten muss.

[http://wiki.neo-guerillaz.de Projekt und Doku]

Der Autor stellt zwei über das Internet erreichbare Testboards bereit unter http://www.neo-guerillaz.de:81 und http://www.neo-guerillaz.de:82 die beide unter OpenMCP laufen, je auf einen AVR-NETIO mit einem ATmega644 und dem eigentlichen Board mit einem ATmega2561. Zusätzlich ist gerade eine Version für das myAVR in Arbeit die schon ordentlich Fortschritte macht.

=== ENC28J60 I/O-Webserver von Thomas Heldt ===

Ein Modul-Webserver (Softwarekompatibel zum Pollin Webserver), der durch div. Module erweitert werden kann, Software in Bascom basierend auf dem Code von Ben Zijlsta wurde erweitert und angepasst:

[http://mikrocontroller.heldt.eu/index.php?page=enc28j60-io-webserver Projekt und Software]

== Siehe auch ==
* Diskussion zu diesem Projekt: http://www.mikrocontroller.net/topic/109988
* [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en022889 ENC28J60 Produktseite]
* [http://ww1.microchip.com/downloads/en/DeviceDoc/39662c.pdf ENC28J60 Datenblatt(pdf)]
* [http://son.ffdf-clan.de Forum für AVR-Net-IO]
* [http://bascom-forum.de/index.php/topic,1781.0.html Bascom Forum ]
* [http://hobbyelektronik.org/w/index.php/AVR-NET-IO-Shield Shield für den NET-IO]

[[Category:AVR-Boards]]
[[Category:Ethernet|P]]

Benutzer Diskussion:Haku

2011-10-28T14:49:54Z

Kruemeltee: Die Seite wurde neu angelegt: „Hehe, deine Orden gefallen mir ;)“

Hehe, deine Orden gefallen mir ;)

Benutzer:Kruemeltee

2011-10-07T07:41:19Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei meiner Seite */

== '''Schaut doch mal hier vorbei [[Mini2440]] und bei [http://krumeltee.wordpress.com/ meiner Seite]''' ==

Eigene '''Eagle-Libraries''':
* [[Datei:mos6581_sid.lbr]] DIP
* [[Datei:at89c51ac3.lbr]] PLCC52 gesockelt, smd
* [[Datei:at89c51ed2.lbr]] PLCC68 gesockelt
* [[Datei:ds89c450.lbr]] DIP40
* [[Datei:max127.lbr]] DIP
* [[Datei:max520.lbr]] DIP
* [[Datei:PCA9517.lbr]] SMD
* [[Datei:tlc540.lbr]] DIP

[http://www.mikrocontroller.net/articles/Datei:I2ctools_avr32_grasshopper_ngw100_stk1000.tar.bz2 i2ctools (i2cdetect, i2cdump, i2cget, i2cset) compiliert für AVR32-Linux (Grasshopper, NGW100, STK1000).]

[http://www.mikrocontroller.net/articles/Datei:Max127_avr32.tar.bz2 C-Code zum Auslesen eines MAX127 12Bit I²C ADCs an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:LM75_avr32.tar.bz2 C-Code zum Auslesen eines LM75 I²C Temperatursensors an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:PCF8574_avr32.tar.bz2 C-Code zum Setzen/Auslesen eines PCF8574 8Bit Portexpanders an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/wikifiles/c/ca/Saa1064_avr32.tar.bz2 C-Code für einen SAA1064 4 Digit 7 Segment Treiber via I²C am AVR32]

[http://www.mikrocontroller.net/wikifiles/8/88/Saa1064_schem.jpg Schaltplan SAA1064]

[http://www.mikrocontroller.net/attachment/highlight/54535 SDCC Header File für den Controller '''T89C51AC3''' von Atmel.]

Datei:Mos6581 sid.lbr

2011-10-07T07:40:56Z

Kruemeltee:

Datei:Tlc540.lbr

2011-10-07T07:40:00Z

Kruemeltee:

Datei:PCA9517.lbr

2011-10-07T07:39:51Z

Kruemeltee:

Datei:Max520.lbr

2011-10-07T07:39:42Z

Kruemeltee:

Datei:Max127.lbr

2011-10-07T07:39:34Z

Kruemeltee:

Datei:Ds89c450.lbr

2011-10-07T07:39:22Z

Kruemeltee:

Datei:At89c51ed2.lbr

2011-10-07T07:38:52Z

Kruemeltee:

Datei:At89c51ac3.lbr

2011-10-07T07:38:38Z

Kruemeltee:

AVR Net-IO Bausatz von Pollin

2011-09-21T10:52:34Z

Kruemeltee: /* Bekannte Fehler */

Hier steht eine Beschreibung des Pollin Bausatzes [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=NQ==&a=MTQ5OTgxOTk= AVR-NET-IO. Best.Nr. 810 058], oder als aufgebautes Fertigmodul, Best.Nr. 810 073.

Einige Features: Ethernet-Platine mit ATmega32 und Netzwerkcontroller ENC28J60. Die Platine verfügt über 8 digitale Ausgänge, 4 digitale und 4 ADC-Eingänge, welche alle über einen Netzwerkanschluss (TCP/IP) abgerufen bzw. geschaltet werden können.

[[Datei:AVR-NET-IO ADD-ON.JPG|thumb|right|400px|AVR-NET-IO (links) mit zusätzlicher SUB-D Anschlussplatine (rechts, nicht im Lieferumfang)und Add-On-Board (oben, mit aufgelötetem RFM12-433-Modul, beides nicht im Lieferumfang). Ebenso ist zusätzlich ein nicht im Lieferumfang enthaltener kleiner Kühlkörper auf einem der Spannungsregler montiert und die Schraubklemmen zur Stromversorgung wurden durch Buchsen ersetzt.]]

== Technische Daten ==

* Betriebsspannung 9 V AC/DC
* Stromaufnahme ca. 190 mA
* 8 digitale Ausgänge (0/5 V) [PC0-PC7 an J3]
* 4 digitale Eingänge (0/5 V) [PA0-PA3 an J3]
* 4 ADC-Eingänge (10 Bit) [PA4-PA7 an Schraubklemmen]
* LCD-Anschluss (HD44780 komp. Controller nötig) [PD2-7,PB0,PB3 an EXT]
* [[ENC28J60]]
* [http://www.atmel.com/dyn/Products/Product_card.asp?part_id=2014 ATmega32] Mikrocontroller

Maße (L×B×H): 108×76×22 mm.

== Hardware ==

Die Schaltung des AVR-NET-IO ist recht einfach:
* Ein ATmega32 Mikrocontroller enthält die gesamte Software
* Ein ENC28J60 Ethernet-Controller für das Senden und Empfangen von Ethernet Frames (MAC und PHY Ethernet Layer) ist über [[SPI]] mit dem ATmega32 verbunden
* Ein Ethernet RJ-45 MagJack TRJ 0011 BA NL von [http://www.trxcom.com/ Trxcom] mit eingebautem Übertrager und Anzeige-LEDs am ENC28J60.
* Ein MAX232 für die serielle Schnittstelle
* Zwei Spannungsregler, 5 V und 3,3 V
* "Hühnerfutter"

Fast alle I/O Pins des ATmega32 sind irgendwo auf Anschlüssen herausgeführt. Entweder auf dem SUB-D Stecker, dem EXT oder ISP Wannensteckern oder den blauen Anschlussklemmen. Eine Schutzbeschaltung gibt es nicht.

Die blauen Anschlussklemmen haben eine Nut und eine Feder mit denen man
sie zusammenstecken kann, dadurch ist das Anlöten wesentlich leichter
und sie stehen auch sauber in der Reihe.

=== Erweiterungsplatine ===

Seit Januar 2010 gibt es auch eine Erweiterungsplatine

[http://www.pollin.de/shop/dt/Nzg4OTgxOTk-/Bausaetze/Diverse/Bausatz_Add_on_fuer_AVR_NET_IO.html Add-on für AVR-NET-IO-Board Best.Nr. 810 112]

Diese Platine erweitert das NET-IO um:

* SD-Karten-Slot über SPI
* Display über PCF 8574
* Infrarot
* [[RFM12]] Funkmodul (nicht im Lieferumfang enthalten)

Ausserdem soll es die 3.3V Versorgung der Hauptplatine verbessern. Dazu sollte man einen 4,7 kOhm Widerstand parallel zu R2 schalten. Sonst beträgt die Ausgangsspannung nur ca. 2,8V. (Tipp aus dem u.g. Thread im Forum)

Um bei einem Neuaufbau parallele Widerstände zu vermeiden, sollten folgende Änderungen auf dem Addon-Board gemacht werden:
*R2 1,5kΩ ersetzen mit 2kΩ
*R3 1,8K ersetzen mit 3,3kΩ
*R19 470kΩ ersetzen zu 470Ω
*Q1 BC548 ersetzen durch BC327 oder BC328 (Hauptsache PNP! und mehr als 100mA)

Stand Feb. 2011: R2 wird mit 2,2kΩ und R3 wird mit 3,6kΩ ausgeliefert. Somit werden die 3,3 V richtig erzeugt. R19 hat 470Ω.

Der ISP-Anschluß ist nicht vollständig durchgeschleift, es besteht keine Verbindung der RESET-Leitung zwischen ISP und ISP1 (Abhilfe: Drahtbrücke einlöten, [http://www.mikrocontroller.net/topic/161354#1600385 Quelle]).

Erste Erfahrungsberichte im Forum http://www.mikrocontroller.net/topic/161354

=== Hardware-Umbauten & -Verbesserungen ===

* Kühlkörper auf dem 7805
* MAX232 nach anfänglicher Konfiguration nicht bestücken um Strom zu sparen oder um zwei weitere I/O-Pins zu gewinnen
* 10µF-Elkos für MAX232N (C14-C17) durch 1µF ersetzen. Eine 10µF-Version für den MAX232 gibt es nicht. Die 10µF-Elkos können auch Ursache einer nicht funktionierenden RS232 sein.
** Laut Spezifikation sind auch mehr als 1uF erlaubt. Selbst Atmel verwendet beim STK500 10uF. Dies führt keinesfalls dazu, dass die RS232 nicht mehr funktioniert.
* Die IC-Fassungen aus "Pollins Resterampe" durch Fassungen mit gedrehten Kontakten ersetzen.
* ''Netz'' LED nicht bestücken oder größere Widerstände einlöten um Strom zu sparen
* Vorwiderstände der Ethernet-LEDs größer machen (z. B. verdoppeln) um Strom zu sparen
* Linear-Spannungsregler ersetzen
* Kondensator an AREF-Pin des ATmega32 (ATmega32 Datenblatt) (100nF gegen Masse)
* Kondensator an den RESET-Pin des ATmega32 ([http://www.atmel.com/dyn/resources/prod_documents/doc2521.pdf Atmel Application Note AVR042: AVR Hardware Design Considerations]) Wenn man diese Quelle genauer liest, ist das aber eher unnötig. - Kondensator bei selbstbau-ISP empfehlenswert.
* Umbau auf 3,3 V:
** Ersatz der Spannungsregler durch einen einzigen 3,3 V Regler
** Anpassen (verkleinern) des LED-Vorwiderstands R3 für 3,3 Volt Betrieb
** Reduktion der Taktfrequenz (Austausch von Q2) auf den bei 3,3V erlaubten Bereich des ATmega32 ( ATmega32(L) 3.3V /8.0 Mhz Takt )
** Ersatz des MAX232 durch einen MAX3232
[[Bild:POWER.JPG|thumb|400px|5V Stromversorgung über USB Kabel, ohne 5 V Spannungsregler und Gleichrichterdioden, Vorsicht: kein Verpolungsschutz! ]]
* ATmega32 vom ENC28J60 takten (OSC2)
* Betrieb mit Gleichspannung:
** Dioden D2 und D5 durch Drahtbrücken ersetzen, D1 und D4 nicht bestücken (komplette Entfernung des Brückengleichrichters, beinhaltet Verlust des Verpolungsschutzes)
** Diode D2 bestücken, D5 durch Drahtbrücke ersetzen, D1 und D4 nicht bestücken (Brückengleichrichter durch Verpolungsschutze ersetzen)
*** ??? Ist dies nicht kontraproduktiv? Bei mir wurde durch D2-Bestückung die Eingangsspannung von ca. 5,2 V am LM317T auf ca. 4,6 V gedrückt, so dass am ENC28J60 nur ca. 2,6 V ankamen (außerhalb der lt. Datenblatt "Operating voltage range of 3.14V to 3.45V"). Man müsste also ein geregeltes Netzteil mit ca. 5,5 V anschließen um 5 und 3,3 V zu erzielen. Dann lieber den Verpolungsschutz durch andere Maßnahmen sicherstellen.
** Beim Betrieb von USB beachten, dass USB-Spezifikation keinesfalls 5V garantiert, sondern Spannung bis runter 4.4V erlaubt und dann u.U. durch den LM317 nicht mehr genügend Spannung am ENC anliegt. Das äußert sich so, dass zwar der Atmega einwandfrei funktioniert, die Ethernet-Kommunikation aber nicht oder nur sehr sporadisch.
* Ersatz des ATmega32 durch einen ATmega644 mit mehr FLASH-Speicher.

== Inbetriebnahme der Originalsoftware ==
=== Einleitung ===

Die bei Auslieferung (Stand September 2008) in den ATmega32 gebrannte Firmware stellt sich manchmal recht zickig an. Es scheint dann die Netzwerk-Schnittstelle, ggf. auch die seriell Schnittstelle, nicht zu funktionieren. Falls es Probleme geben sollte, sollte man erst einmal einen Firmwareupdate versuchen. Dies geschieht über die serielle Schnittstelle mittels des Programmes NetServer (aktuelle Version 1.03, Februar 2010), die dem Bausatz beiliegt.

Falls die serielle Schnittstelle ebenfalls nicht zugänglich ist, kann mit den im folgenden beschriebenen Schritten die Inbetriebnahme der Software möglich sein. Dazu benötigt man:

* Einen Windows-PC mit Ethernet-Schnittstelle und RS232-Schnittstelle (ein Prolific RS232-USB Konverter funktioniert)
* Entweder
**zwei normale (''straight through'') Ethernet-Kabel und einen Ethernet Switch/Hub, oder
**ein gekreuztes(''cross over'') Ethernet-Kabel
* Einen AVR Programmer (Hardware und Software). Zum Beispiel einen [[AVR Dragon]] oder [[STK500]] mit [[AVR Studio]] oder das [[Pollin ATMEL Evaluations-Board]] und [[avrdude]].
* Die [http://www.pollin.de/shop/ds/MTQ5OTgxOTk-.html Pollin NetServer Software], Version 1.03 (oder neuer)

=== Gelieferten ATmega32 richtig einstellen ===
[[image:fuse_bits_avr_studio.jpg|thumb|right|250px|Einstellungen der Fuse-Bits mittels AVR Studio 4]]
Die Fuses der gelieferten ATmega32s scheinen nicht immer mit den im Handbuch auf Seite 12 als erforderlich angegebenen Fuse-Einstellungen übereinzustimmen.

Dies kann man mittels eines Programmers ändern. LFuse = 0xBF, HFuse = 0xD2. Das genaue Vorgehen hängt dabei vom verwendeten Programmer ab. Bei der Gelegenheit kann man ebenfalls eine Sicherheitskopie des ursprünglichen Flash-Inhalts und des EEPROMs anfertigen. Das EEPROM scheint die MAC-Adresse des Ethernet-Ports zu enthalten.

Entgegen der Spezifikation im Handbuch von Pollin sollten die '''HFuses auf 0xC2''' gesetzt werden, d. h. CKOPT-Fuse programmiert (dies ist in der Software Version 1.03 bereits vollzogen). Das sorgt für einen stabilen Betrieb des AVR-Oszillators im "full rail-to-rail swing"-Mode bei 16 MHz. Atmel garantiert ansonsten nur stabilen Betrieb bis 8 MHz. Siehe ATmega32-Datenblatt, Kapitel 8.4, Crystal Oscillator.
{{Absatz}}

==== Funktionsfähige Konfiguration - AVR-Prog ====

[[Bild:Avrprog.png|thumb|right|250px]]
Benutzer von AVR-Prog können die nachfolgenden Einstellungen für die Lock- und Fuse-Bits verwenden. Hierbei handelt es sich um die ausgelesenen Einstellungen eines funktionsfähigen Controllers. Allerdings sollte, laut Handbuch des AVR-NET-IO-Boards, das Fuse-Bit EESAVE eigentlich gesetzt sein.

Alternativ kann auch per avrdude die Einstellung getroffen werden:
avrdude -c stk500v2 -pm32 -U lfuse:w:0xBF:m
und
avrdude -c stk500v2 -pm32 -U hfuse:w:0xC2:m

Anschließend muß noch der Bootloader und die Firmware aktualisiert werden (siehe Handbuch AVR-NET-IO-Board Seite 12 Punkt 3).

=== PC Konfiguration ===

==== PC normalerweise nicht im 192.168.0.0/24 Subnetz ====

Betreibt man den PC nicht im 192.168.0.0/24 Subnetz, muss er wie folgt umkonfiguriert werden, oder die IP Adresse des Boards wird entsprechend angepasst. ( Siehe Handbuch Seite 14ff. Das ist meist sinnvoller und auch einfacher. )

Den PC vom normalen Netzwerk abstecken[1]. Zur Umkonfiguration dazu bei Windows XP in der Systemsteuerung ''Netzwerkverbindungen'' aufrufen und die lokale ''LAN-Verbindung'' markieren. Dann in der rechten Leiste ''Einstellungen dieser Verbindung ändern'' aufrufen.

Es erscheint der Dialog ''Eigenschaften von <Verbindungsname>''. In der Liste im Dialog zu ''Internetprotokoll (TCP/IP)'' gehen. Ein Doppelklick auf den Eintrag öffnet den ''Eigenschaften von Internetprotokoll (TCP/IP)'' Dialog.

In diesem Dialog ''Folgende IP-Adresse verwenden:'' auswählen und zum Beispiel

IP-Adresse: '''192.168.0.100''' 
Subnetzmaske: '''255.255.255.0''' 
Standardgateway: '''192.168.0.1'''

eingeben.

Anmerkung von bitman:
[1] Dies ist spätestens ab Windows XP nicht mehr notwendig, wenn das Netz 192.168.0.0/24 noch frei ist. Dann kann man einfach den Client ''zusätzlich'' in diesem Netzwerk zusätzlich einbinden über Einstellungen/Netzwerkverbindungen/Lanverbindung/Eigenschaften/TCP-IP/Eigenschaften/Erweitert/IP-Adresse hinzufügen. Es werden dann eben mehrere IP-Adressen an den NIC gebunden.

Alle geöffneten Dialoge nacheinander mit OK schließen.

Alternativ bietet sich das Umprogrammieren des Boards über die serielle Schnittstelle an. Die Werte für IP-Adresse, Netzmaske und Standard-Gateway werden mit den dokumentierten SETxx-Befehlen geändert, das Board neu gestartet und ans vorhandene Netzwerk gesteckt.

Im EEPROM sind folgende Werte vorprogrammiert: 
3EE - 3F3 MAC-ADRESSE 
3F4 - 3F7 GATEWAY 
3F8 - 3FC NETMASK 
3FD - 3FF IP-ADRESSE 

==== PC bereits im 192.168.0.0/24 Subnetz ====

In diesem Fall muss man prüfen, ob die IP-Adresse 192.168.0.90 bereits im Subnetz verwendet wird. Ist dies der Fall, muss das verwendete Gerät mit dieser IP vorübergehend aus dem Subnetz entfernt werden. Es sei denn, dabei handelt es sich um den PC. In diesem Fall muss er wie zuvor umkonfiguriert werden. Ansonsten kann der unverändert im Netz verbleiben.

Dem AVR-NET-IO gibt man eine neue, zuvor unbenutzte Adresse (siehe unten). Dann kann das abgekoppelte Gerät wieder angeschlossen werden, beziehungsweise der PC zurückkonfiguriert werden.

=== AVR-NET-IO anschließen ===

Musste man den PC umkonfigurieren, so werden jetzt nur der PC und der AVR-NET-IO über Ethernet miteinander verbunden. Je nach Ethernet-Kabel benötigt man dazu einen Switch/Hub oder nicht.

Musste man den PC nicht umkonfigurieren, so kann man den AVR-NET-IO wie einen normalen Rechner an das vorhandenen Netz anschließen.

Zusätzlich schließt man die serielle Schnittstelle des AVR-NET-IO an den PC an.

=== Firmware 1.03 einspielen ===

Laut Handbuch sollte der AVR-NET-IO jetzt über Ethernet funktionieren. Ebenso sollte er über die serielle Schnittstelle und ein Terminalprogramm konfigurierbar sein. Beides ist offensichtlich im Auslieferungszustand selten der Fall.

Auch wenn sich Pollins NetServer Software nicht mit dem AVR-NET-IO verbinden lässt, so ist sie jedoch in der Lage eine neue Firmware 1.03 einzuspielen. Das Vorgehen ist im Handbuch auf Seite 12 beschrieben. NetServer präsentiert dabei ein paar einfache Anweisungen denen man folgen sollte.

=== Abschluss ===

Jetzt sollte sich die NetServer Software mit dem AVR-NET-IO über Ethernet verbinden lassen. Dies macht es wiederum möglich, den AVR-NET-IO mit einer anderen IP-Adresse zu versehen. Will man den AVR-NET-IO in einem anderen Subnetz betreiben kann man dies jetzt einstellen.

Nachdem man die IP-Adresse neu eingestellt hat, muss man den PC zurückkonfigurieren und kann dann sowohl den AVR-NET-IO und den PC zusammen betreiben.

== Bekannte Fehler ==

Siehe auch [[#Hardware-Umbauten_.26_-Verbesserungen|Hardware-Umbauten und Verbesserungen]] 
Käufer berichten von fehlenden Bauteilen im Bausatz (Wannenstecker, Widerstände, Kondensatoren, Induktivitäten). Für Reklamationen: [https://www.pollin.de/shop/kontakt_service/reklamation.html]

* Die Stückliste auf Seite 4 in den Anleitung mit den Versionsangaben
** ''Stand 20.08.2008, kloiber, #1100, wpe'' (gedruckt im Bausatz)
** ''Stand 20.08.2008, cd, #all, wpe'' (auf der CD)
:ist falsch. Pollin legt dem Bausatz irgendwann ab September 2008 einen gedruckten Korrekturzettel bei. Die Online-Version der Anleitung ist korrigiert.
* Im Schaltplan auf Seite 7 in den Anleitungen mit den Versionen
** ''Stand 20.08.2008, kloiber, #1100, wpe'' (gedruckt im Bausatz)
** ''Stand 20.08.2008, cd, #all, wpe'' (auf der CD)
** ''Stand 03.09.2008, online, #all, wpe'' (Online)
:ist eine 25-polige SUB-D Buchse gezeichnet. Geliefert wird und in der Stückliste verzeichnet ist ein Stecker.

* Die September 2008 ausgelieferte Firmware im ATmega32 funktioniert bei vielen nicht und muss erst upgedatet werden (siehe [[#Inbetriebnahme der Originalsoftware|Inbetriebnahme der Originalsoftware]])

* Im Flash der gelieferten AVR ist anders als beschrieben nur der Bootloader enthalten, die eigentliche Firmware muss erst mit Hilfe der Updatefunktion geladen werden. Wenn zusätzlich auch die Fuses falsch gebrannt sind, dann funktioniert das Update nicht, auch wenn das PC Programm was anderes behauptet.

* Die Fuse-Einstellungen des ausgelieferten ATmega32 entspricht nicht der Anleitung (siehe [[#Inbetriebnahme der Originalsoftware|Inbetriebnahme der Originalsoftware]])

* Bausatz, gekauft am 27.10.08, Anleitungsversion 19.09.08, ohne Probleme oder erkennbare Fehler zusammengebaut und in Betrieb genommen.

* Bausatz gekauft 29.09.2008, Pinbelegung des 25 poligen D-Sub "Anschlusses" stimmt nicht mit der Anleitung überein. Der Aufdruck auf der Platine ist falsch. Pin1 <-> Pin13, Pin2 <-> Pin12 usw. Setzt man den D-Sub Stecker ein, so sind dessen Pinnummern korrekt. Bei einem Bausatz gekauft 10/2010 ist dies ebenfalls noch der Fall.

* 3 Bausätze Anf. Oktober 2008 gekauft, bei einem waren 2 LM317 dabei, dafür fehlte der 7805 - aus der Bastelkiste ersetzt. Alle haben jedoch auf Anhieb funktioniert

* Bausatz gekauft Ende Januar 2009. Die Lock-Bits (u.a. für PonyProg2000) werden falsch beschrieben. Die in Klammern aufgeführten Werte stimmen bei einem Bit nicht. Die Texte "Programmiert/Unprogrammiert" hingegen schon. Bei den Bauteilen gab es 4 Kondensatoren mit der Aufschrift "220", ich habe diese durch welche mit 22p ersetzt, da ich nicht sicher war ob wirklich 22p geliefert wurden. Dafür wurden statt einem zwei 7805 und statt einem mindestens vier LM317 mitgeliefert.

* Bausatz geliefert 22.4.2009. Alles vollständig, zusammengebaut, läuft. Software-Version 1.03. Für den oben schon genannten Steckverbinder wurde eine Buchse geliefert. Allerdings stimmen die PIN-Nummern im Schaltplan nicht mit den PIN-Nummern auf der Buchse überein (sie sind gespiegelt), daher liefen die Test-LEDs zunächst nicht.

* Bausatz geliefert 11.7.2009. Spannungsregler LM317T fehlt, grüne statt roter LED. Ein Kondensator 22pF zu viel. LM317T wurde auf Anfrage kostenlos nachgeliefert (27.7.). Inbetriebnahme problemlos.

* Bausatz geliefert 24.7.2009. Ein Quarz 16MHz zu viel, ebenfalls grüne statt rote LED.

* Bausatz geliefert 20.08.2009. Ein Kondensator 22pF zuviel und grüne statt rote LED.

* Bausatz Juli '09 gekauft, grüne statt rote LED

* Bausatz 25.09.09 geliefert, grüne Betriebs-LED, ein ELKO zuviel, Fehler 1µF am MAX232 statt 100nF behoben, richtiger C wird mitgeliefert, Aufbau komplett nach Pollin Anleitung durchgeführt, auf Anhieb fehlerfrei!

* Bausatz 17.10.09 geliefert, grüne Betriebs-LED, zwei 100nF Kondensatoren zu wenig. Aufbau und Inbetriebnahme problemlos.

* Bausatz 21.10.09 gekauft, grüne Betriebs-LED. Aufbau problemlos, RS232 läuft nicht. LAN läuft

* Bausatz Nov. 09 gekauft, grüne LED, alles o.k.

* Bausatz Nov. 09 gekauft, grüne LED, ENC28J60, MAX232 und ATmega32 fehlen, Nachlieferung nach einer Woche

*Bausatz Nov. 09 gekauft,Bauteile komplett.Verbindungsaufbau Seriell klappt erst nach mehreren Versuchen.Problem gelöst:Spannung an MAX und Mega zu niedrig

* Bausatz Dez. 09 gekauft, grüne LED, 100µF Kondensator fehlt, alles o.k.

* Bausatz August 09 gekauft, alle teile da nach Einstellen der fusebits lief alles perfekt

* Bausatz Okt. 09 gekauft, ein 100nF Kondensator und 25MHz Quarz fehlten ... hab beim lokalen Elektronikhändler keinen 25Mhz Grundton Quarz sondern nur im 3. Oberton bekommen aber mit R2.2k parallel zum Quarz schwingt er in der Schaltung schön bei 25Mhz. Mit 1µF am MAX232 funktioniert jetzt auch die RS232.

* 2x Bausatz Feb. 10 gekauft, bei beiden fehlten 7805, L1+L2 je 100µH sowie 4x falscher Wert Kondensator an Max232 vorhanden. Fehlende Bauteile nachgelötet und Funktion getestet. Hat alles einwandfrei funktioniert!!!

* Bausatz März. 10 gekauft, RS232 Printbuchse fehlt, dafür 1x 10pol Wannenstecker zuviel. Grüne LED statt Rot. Funktioniert ansonsten einwandfrei.

* Bausatz Jan. 10 gekauft, gelbe LED statt rot, C14...C17: 10uF, weder seriell noch via Ethernet Konnektivität. Nach Austausch von C14-C17 gegen 1uF, wenigstens serielle Kontaktaufnahme möglich, kein Ethernet auch nach Flash von 1.03 mit NetServer.

* Bausatz Feb. 10 gekauft, Spannungsregler LM317T fehlte

* Bausatz März 10 gekauft, gelbe statt rote LED geliefert, aber Aufbau und inbetriebnahme lt. Handbuch ohne Probleme

* Bausatz März 10 gekauft und gelbe statt rote LED geliefert, funzt wunderbar gemäß Anleitung

* Fertig gelötete Platine gekauft. µC war falsch im Sockel.

* Bausatz April 10 gekauft und gelbe statt rote LED geliefert, ADM232LJN statt MAX232 - Funktion erst nach Ersetzung des ADM durch nen MAX

* Bausatz April 10 gekauft und gelbe statt rote LED geliefert, ADM232LJN statt MAX232 - funktionierte sofort auch mit dem ADM232LJN.

* Bausatz April 10 gekauft wurde mit grüner statt roter LED Ausgeliefert

* Bausatz Juni 10 gekauft: wurde mit grüner statt roter Netz-LED ausgeliefert, 2x 22pF Kerko zuviel

* Bausatz August 10 gekauft: komplett und sofort funktioniert
* Bausatz Juli 10 gekauft: 2 Quarze mit 16 MHz geliefert, statt 1x 16MHz und 1x25MHz.
* Bausatz September 10 gekauft: hat sofort funktioniert. 1x 3,3k und 1x 10k Widerstand zuviel. Statt 100nF Kondensatoren wurden 1µF geliefert -> Platzprobleme auf der Platine durch grössere Bauform. LED grün.
* Bausatz Oktober 6 gekauft: alles funktioniert. LED grün statt rot.

* Fertigmodul Oktober 10 gekauft: Auf Anhieb alles funktioniert!
* Bausatz Oktober 10 gekauft: komplett und sofort funktioniert

* Bausatz November 10 gekauft: komplett und sofort funktioniert (sogar mit der neusten Pollin Firmware 1.03 schon drauf) LED grün statt rot.

* Bausatz November 10 gekauft. Nach Bezug neuer Feinst-Lötspitzen konnte ich ihn dann auch zusammenlöten. Es hat sofort alles funktioniert, obwohl ich nur 12V bzw. 9V Gleichspannung zur Verfügung hatte, und nicht sicher war, wieviel die Komponenten wirklich benötigen. Der Regler wird auch bei 9V Gleichspannungsversorgung noch sehr warm. Da muss auf jeden Fall ein Kühlkörper dran! Ich habe auch eine grüne LED bekommen, ist mir aber wurscht :-)

* Bausatz Dezember 10 gekauft: komplett und funktionierte sofort. Firmware 1.03, grüne LED (Ein Quarz und ein IC-Sockel zu viel)

*Bausatz Januar 2011 gekauft: nur genau die richtige Anzahl Teile dabei, Firmware 1.03, grüne LED, ging auf Anhieb

* 2x Bausatz Januar 2011 gekauft: beide grüne LED, und 1x doppelter Satz Jumper/Stiftleiste, 22PF und Anschlussklemmen. Rest vollständig und beide haben sofort nach zusammenbau funktioniert.

* Februar 2011: AVR-NET-IO: die Diode D5 fehlt, 10 µF gegen 1 µF für MAX232 getauscht, Flash im ATmega32 war programmiert, passende IP-Adr über serielle Schnittstelle eingestellt; ADD-ON: für R1 war 22 Ohm statt 0,2 Ohm beigelegt, durch richtigen ersetzt, Beschreibung der LED Bestückung mangelhaft / oe1smc

* Februar 2011: AVR-NET-IO: 1 Diode zuviel, 2 Spulen fehlen, LED grün. Die fehlenden Spulen wurden durch welche aus der Bastelkiste ersetzt - funktioniert. Der 7805 bekam einen kleinen Kühlkörper spendiert.

* Februar 2011: AVR-NET-IO: 2x 10k Widerstände fehlen. Dafür eine Diode zu viel.

* Ende Februar 2011: Zwei Bausaetze an jeweils zwei Adressen, alles in Ordnung.

* Ende März 2011: 2x 25 Mhz Quarz statt 1x16 u. 1x25 Mhz. LED fehlt. Bausatz funktioniert nach Tausch des Quarz den mir mein Freund oe9rsv aus seinem Fundus spendiert hat. Danke auch für die Hilfe beim Fehler suchen.

* Mitte 2010 gekauft: 1x 100nF fehlt

* Mitte Juni 2011: Beide Quarze fehlen und beide Spannungsregler fehlen, Pollin wollte, dass ich das ganze Paket zurückschicke für einen Austausch. Ein 51 Ohm zu viel. 16Mhz im Handel und 25Mhz vom alten Mobo ausgelötet. Läuft wunderbar.

* Anfang Juni 2011: Beide Quarze fehlen und beide Spannungsregler fehlen, nach kurzer Mail an Pollin (leider ohne Antwort) wurden diese nach ca. 1 Woche in einem Brief nachgeliefert.

* August 2011: alles 1a...
* August 2011: Platine fehlte -> in Nachlieferung
* 30 August 2011: alles 1a...
* 06 Sep. 2011: alles 1a...
* August 2011: 6 Stück bestellt, bei einem haben die 100nF Kondensatoren gefehlt, bei einem zwei LM317 statt 7805 und LM317. Angerufen, 3 Tage später Nachlieferung erhalten.

== Andere Software für den Client-PC ==
=== NetIOLib ===

In C# geschriebene Bibliothek zur Ansteuerung der Platine im Orginalzustand. Inkl. Beispielsoftware und Quellcode (GNU GPL)

DLL: [http://www.tware.org/downloads/NetIOLib_dll.zip Download-Link]
Source: [http://www.tware.org/downloads/NetIOLib_src.zip Download-Link]

=== ControlIO ===
Einfache Bibliothek zur Ansteuerung mit Originalfirmware.
http://www.mikrocontroller.net/topic/149695

=== JAVA Lib ===
Einfache Java-Bibliothek zur Ansteuerung mit Originalfirmware.
http://son.ffdf-clan.de/?path=forumsthread&threadid=611

=== App NetIO ===
Frei verfügbare App für Windows Mobile zur Ansteuerung mit der Orginalsoftware. Das HTC HD2 wird damit zur Fernsteuerung für das AVR Net-IO Board.
http://www.heesch.net/netio.aspx

=== PHP ===
PHP Klasse zur Ansteuerung mit der Originalfirmware. (Opensource Lizenz)
http://blog.coldtobi.de/1_coldtobis_blog/archive/298_pollin_net-io_php_library.html

PHP Funktionen zum Ansteuern der Originalfirmware. (Free for All Lizenz)
http://defcon-cc.dyndns.org/projects/mikrocontroller/netio.php

=== NET-IO Control ===
Eine Application für das Android Betriebssystem zur Steuerung des AVR Net-IO Boards http://elektronik2000.de/

=== E2000 - Logik (V 1.2@1.3.1c) ===
[[Datei:E2000-Logik-Bedienoberflaeche.jpg|600px|rechts]]

Anwenderfreundliche Logik-Software vom Elektronik2000.de zur Steuerung des AVR-NET-IO über den Computer (in zukunft auch Autark laufend auf dem Atmel).

Das designen von Schaltaufgaben wird in diesem Programm grafisch dargestellt. Außerdem besitzt die Software einen Kennlinienschreiber und ein Webinterface.

'''HINWEIS:''' Mit der aktuellen Alphaversion ist es nun möglich das NET-IO upzudaten und somit autark laufen z lassen.

Team:[http://www.elektronik2000.de E2000-Logik]

== Andere Software statt der Originalsoftware von Pollin ==

Die Umrüstung auf einen Webserver durch Austausch der Software (und ev. des ATmega32) bietet sich an. Kleiner Hinweis dabei: wenn zum Flashen ein ISP-Adapter verwendet wird, diesen unbedingt vor dem Start der neuen Software abziehen! Der ISP arbeitet nämlich über dieselbe SPI-Schnittstelle über die auch der ENC28J60 angesteuert wird. Ein eventuell noch angeschlossener, wenn auch passiver ISP-Adapter stört diese Kommunikation, d.h. das Programm an sich scheint zu laufen, aber die Ethernet-Schnittstelle funktioniert nicht.

=== Bascom Version von Hütti ===

(Quelle: http://bascom-forum.de/index.php/topic,1781.45.html )
dort am Ende der Seite.

=== Ben's Bascom Quellcode ===

(Quelle: http://members.home.nl/bzijlstra/software/examples/enc28j60.htm )

Muss aber für Bascom 1.11.9.3 angepasst werden, siehe Code von Hütti !

=== U. Radigs Webserver ===

Angepasster Sourcecode von U.Radig: http://www.mikrocontroller.net/attachment/40027/Webserver_MEGA32.hex
oder selbst anpassen:
Ändere im File ENC28J60.H
#define ENC28J60_PIN_SS 3
#define ENC28J60_PIN_CS 4
(Quelle: http://www.mikrocontroller.net/topic/109988#988386)

Temporären Dateien (*.d, *,lst,*.o) vorher im Verzeichnis löschen ''make clean'', damit neu compiliert wird.

IP: 192.168.0.99 
User: admin 
Pass: uli1 

Den orginal SourceCode gibt's übrigens hier:http://www.ulrichradig.de/home/index.php/avr/eth_m32_ex

Bei den Fuses BOOTRST ausschalten, da die Software keinen Bootloader enthält.

Wer gerne als Link-LED die grüne nutzen möchte
(U.Radig-Source)

enc28j60.c Zeile 150

"enc28j60_write_phy(ENC28J60_PHY_PHLCON, 0x347A)

Wert 0x347A in 0x374A ändern

(Quelle: http://www.mikrocontroller.net/topic/109988#994943)

IP: 192.168.1.90 
User: admin 
Pass: tim 
Test: http://beitz-online.dyndns.org 
Test: http://pieper-online.dyndns.org 

Weiterentwicklung des Radig-Codes von RoBue: 
- 1-Wire-Unterstützung (Anschlus an PORTA7) 
- PORTA0-3 digitaler Eingang (ein/aus) 
- PORTA4-6 analoger Eingang (0 - 1023) 
- LCD an PORTC 
- Schalten in Abhängigkeit von Temperatur und analogem Wert 
- (Teilweise) Administration über Weboberfläche 
- Erweiterung des cmd-Befehlsatzes für telnet/rs232 
Gedacht ist der Einsatz des AVR-NET-IO-Bausatzes für Heizungs- oder Haussteuerung) 

Test: http://avrboard.eluhost.de/ 

(Quelle: 
http://www.mikrocontroller.net/attachment/43307/AVR-NET-IO_RoBue_V1.3.zip 
http://www.mikrocontroller.net/attachment/44569/AVR-NET-IO_RoBue_V1.4.zip 
http://www.mikrocontroller.net/attachment/46720/AVR-NET-IO_RoBue_1.5-final_hoffentlich_.zip)

Bei der Ver 1.5 sind die Ports PD2+3 fürs 4bit LCD (Ext.) vertauscht ! Gruß B.P

=== Simon Ks Webserver (uip-Stack) ===
Angepasster Sourcecode von Simon K: http://www.mikrocontroller.net/attachment/39939/uWebSrv.zip
IP: 192.168.0.93:8080 

=== Ethersex Server ===

http://www.ethersex.de - Einfach für atmega32 compilieren und funktioniert.

Oder
[http://www.ethersex.de/firmware-builder/list.cgi hier] ein Firmware Image passend für das Pollin Net-IO mit eingebautem Webserver und Beispieldateien im Flash bauen lassen und flashen (firmware-builder). Einfacher geht´s nimmer. :-)

=== Etherrape Server ===

http://www.lochraster.org/etherrape/

ist in jedem Fall hier auch zu erwähnen zumal es sich beim etherrape um das Ursprungsprojekt von ethersex handelt.
Es scheint aber bei der Weiterentwicklung wenig zu passieren.
Ausführliche Dokumentation findet sich unter http://wiki.lochraster.org/wiki/Etherrape

=== Mini SRCP Server (kommerziell, Closed-Source)===

Damit wird die Platine zu einer Modellbahnsteuerung, die
über das Netzwerkprotokoll SRCP mit verschiedenen Programmen
gesteuert werden kann.

[http://www.7soft.de/de/mini_srcp_server/index.html Infoseite] zur Hardware
und das zugrundeliegende [http://www.der-moba.de/index.php/Digitalprojekt Digitalprojekt].

=== AvrArtNode ===

Hiermit kann die Platine zu einem Art-Net Node werden, mit dem sich ein DMX-Universe über Ethernet übertragen lässt. Basiert auf den Quellen von Ulrich Radig.

Dokumentation: [http://www.dmxcontrol.de/wiki/Art-Net-Node_f%C3%BCr_25_Euro Art-Net-Node für 25 Euro]

=== Webserver von G. Menke ===

Ein Webserver (basierend auf den Sourcen von U. Radig), der so angepasst ist, dass alle Ein- und Ausgänge wie bei der originalen Pollin-Software genutzt werden können (8xDIGOUT, 4xDIGIN, 4xADIN). Der Webserver kann daher direkt auf das Net-IO geladen werden. Im ZIP-File sind ein ReadMe und alle C-Sourcen enthalten. Download:
[http://gm.stream-center.de/webserver/ Webserver mit passender IO]

=== OpenMCP ===

Tolles Projekt, welches viele Features bietet und stabil läuft. Hervorzuheben ist die Übersichtlichkeit der Programmteile/Module und die vielleicht nicht ganz komplette Dokumentation. Man merkt das viel Arbeit und Liebe in diesen Projekt steckt. Herausgekommen ist dabei eine einfach zu handhabende Entwicklungsumgebung. Anfänger können, dank des gut durchdachten CGI-System welches sich um alle wichtigen Sachen kümmert, leicht eigene CGI implementieren. Alle Ausgaben erfolgen nur mit printf über die Standardausgabe und werden automatisch richtig per Netzwerk übertragen, dadurch ist es auch für den Anfänger recht gut geeignet, da man sich nicht mit der Netzwerkprogrammierung auseinander setzen muss.

Die Software belegt im Moment (Stand Juli 2010) ca. 55 Kb im Flash, so dass man das Board mit einem grösseren µC (z.B. ATMega644) aufrüsten muss.

[http://wiki.neo-guerillaz.de Projekt und Doku]

Der Autor stellt zwei über das Internet erreichbare Testboards bereit unter http://www.neo-guerillaz.de:81 und http://www.neo-guerillaz.de:82 die beide unter OpenMCP laufen, je auf einen AVR-NETIO mit einem ATmega644 und dem eigentlichen Board mit einem ATmega2561. Zusätzlich ist gerade eine Version für das myAVR in Arbeit die schon ordentlich Fortschritte macht.

=== ENC28J60 I/O-Webserver von Thomas Heldt ===

Ein Modul-Webserver (Softwarekompatibel zum Pollin Webserver), der durch div. Module erweitert werden kann, Software in Bascom basierend auf dem Code von Ben Zijlsta wurde erweitert und angepasst:

[http://mikrocontroller.heldt.eu/index.php?page=enc28j60-io-webserver Projekt und Software]

== Siehe auch ==
* Diskussion zu diesem Projekt: http://www.mikrocontroller.net/topic/109988
* [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en022889 ENC28J60 Produktseite]
* [http://ww1.microchip.com/downloads/en/DeviceDoc/39662c.pdf ENC28J60 Datenblatt(pdf)]
* [http://son.ffdf-clan.de Forum für AVR-Net-IO]
* [http://bascom-forum.de/index.php/topic,1781.0.html Bascom Forum ]
* [http://hobbyelektronik.org/w/index.php/AVR-NET-IO-Shield Shield für den NET-IO]

[[Category:AVR-Boards]]
[[Category:Ethernet|P]]

Benutzer:Kruemeltee

2011-08-22T16:36:06Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei meiner Seite */

== '''Schaut doch mal hier vorbei [[Mini2440]] und bei [http://krumeltee.wordpress.com/ meiner Seite]''' ==

[http://www.mikrocontroller.net/articles/Datei:I2ctools_avr32_grasshopper_ngw100_stk1000.tar.bz2 i2ctools (i2cdetect, i2cdump, i2cget, i2cset) compiliert für AVR32-Linux (Grasshopper, NGW100, STK1000).]

[http://www.mikrocontroller.net/articles/Datei:Max127_avr32.tar.bz2 C-Code zum Auslesen eines MAX127 12Bit I²C ADCs an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:LM75_avr32.tar.bz2 C-Code zum Auslesen eines LM75 I²C Temperatursensors an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:PCF8574_avr32.tar.bz2 C-Code zum Setzen/Auslesen eines PCF8574 8Bit Portexpanders an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/wikifiles/c/ca/Saa1064_avr32.tar.bz2 C-Code für einen SAA1064 4 Digit 7 Segment Treiber via I²C am AVR32]

[http://www.mikrocontroller.net/wikifiles/8/88/Saa1064_schem.jpg Schaltplan SAA1064]

[http://www.mikrocontroller.net/attachment/highlight/54535 SDCC Header File für den Controller '''T89C51AC3''' von Atmel.]

Benutzer:Kruemeltee

2011-08-22T16:35:43Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei meiner Seite */

== '''Schaut doch mal hier vorbei [[Mini2440]] und bei [http://krumeltee.wordpress.com/ meiner Seite]''' ==

[http://www.mikrocontroller.net/articles/Datei:I2ctools_avr32_grasshopper_ngw100_stk1000.tar.bz2 i2ctools (i2cdetect, i2cdump, i2cget, i2cset) compiliert für AVR32-Linux (Grasshopper, NGW100, STK1000).]

[http://www.mikrocontroller.net/articles/Datei:Max127_avr32.tar.bz2 C-Code zum Auslesen eines MAX127 12Bit I²C ADCs an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:LM75_avr32.tar.bz2 C-Code zum Auslesen eines LM75 I²C Temperatursensors an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:PCF8574_avr32.tar.bz2 C-Code zum Setzen/Auslesen eines PCF8574 8Bit Portexpanders an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/wikifiles/c/ca/Saa1064_avr32.tar.bz2 C-Code für einen SAA1064 4 Digit 7 Segment Treiber via I²C am AVR32 (grasshopper/ngw100/...)]
[http://www.mikrocontroller.net/wikifiles/8/88/Saa1064_schem.jpg Schaltplan]

[http://www.mikrocontroller.net/attachment/highlight/54535 SDCC Header File für den Controller '''T89C51AC3''' von Atmel.]

Datei:Saa1064 schem.jpg

2011-08-22T16:34:54Z

Kruemeltee:

Datei:Saa1064 avr32.tar.bz2

2011-08-22T16:24:36Z

Kruemeltee:

Benutzer:Kruemeltee

2011-08-22T16:23:22Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei meiner Seite */

== '''Schaut doch mal hier vorbei [[Mini2440]] und bei [http://krumeltee.wordpress.com/ meiner Seite]''' ==

[http://www.mikrocontroller.net/articles/Datei:I2ctools_avr32_grasshopper_ngw100_stk1000.tar.bz2 i2ctools (i2cdetect, i2cdump, i2cget, i2cset) compiliert für AVR32-Linux (Grasshopper, NGW100, STK1000).]

[http://www.mikrocontroller.net/articles/Datei:Max127_avr32.tar.bz2 C-Code zum Auslesen eines MAX127 12Bit I²C ADCs an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:LM75_avr32.tar.bz2 C-Code zum Auslesen eines LM75 I²C Temperatursensors an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:PCF8574_avr32.tar.bz2 C-Code zum Setzen/Auslesen eines PCF8574 8Bit Portexpanders an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/attachment/highlight/54535 SDCC Header File für den Controller '''T89C51AC3''' von Atmel.]

Benutzer:Kruemeltee

2011-08-15T12:50:47Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei meiner Seite */

== '''Schaut doch mal hier vorbei [[Mini2440]] und bei [http://krumeltee.wordpress.com/ meiner Seite]''' ==

[http://www.mikrocontroller.net/articles/Datei:I2ctools_avr32_grasshopper_ngw100_stk1000.tar.bz2 i2ctools (i2cdetect, i2cdump, i2cget, i2cset) compiliert für AVR32-Linux (Grasshopper, NGW100, STK1000).]

[http://www.mikrocontroller.net/articles/Datei:Max127_avr32.tar.bz2 C-Code zum Auslesen eines MAX127 12Bit I²C ADCs an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:LM75_avr32.tar.bz2 C-Code zum Auslesen eines LM75 I²C Temperatursensors an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/articles/Datei:PCF8574_avr32.tar.bz2 C-Code zum Setzen/Auslesen eines PCF8574 8Bit Portexpanders an einem AVR32 unter Linux.]

[http://www.mikrocontroller.net/attachment/highlight/54535 SDCC Header File für den Controller '''T89C51AC3''' von Atmel.
]

Datei:PCF8574 avr32.tar.bz2

2011-08-15T12:49:03Z

Kruemeltee:

Datei:LM75 avr32.tar.bz2

2011-08-15T12:48:47Z

Kruemeltee:

Datei:Max127 avr32.tar.bz2

2011-08-15T12:36:36Z

Kruemeltee:

Benutzer:Kruemeltee

2011-08-15T12:36:19Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei meiner Seite */

I²C

2011-08-11T12:18:34Z

Kruemeltee: /* Bausteine */

'''I²C''' ist ein synchroner serieller Zweidraht-[[Bus]] (eine Daten- und eine Taktleitung), der für die Kommunikation zwischen [[IC]]s über kleine Distanzen geeignet ist. Entwickelt wurde er Anfang der 80er Jahre von Philips.
Gesprochen "I quadrat C" steht für IIC = Inter [[IC]] Bus. Aus Lizenzgründen heißt der I²C Bus bei manchen Herstellern auch '''TWI''', two wire interface.

== I2C ==
In einem I²C-Bus gibt es mindestens einen Master und bis zu 128 Slaves. Ein I²C-Bus mit mehreren Mastern wird als "Multi-Master-Bus" bezeichnet.
Der (oder die) Master sprechen die Slaves an; ein Slave kann NIE selbstständig Daten senden. Dazu übernimmt der Master, der Daten senden oder empfangen möchte, den Bus und gibt die (7-bit- bzw. 10-bit-)Adresse des Slaves aus, mit dem er kommunizieren möchte. Nach der Adresse teilt der Master dem entsprechenden Slave mit, ob er Daten senden oder empfangen möchte. Danach werden die eigentlichen Daten (entweder vom Master oder Slave) auf den Bus gelegt. Hat der Master den Lese- oder Schreibvorgang abgeschlossen, so gibt er den Bus wieder frei.
Sofern mehrere Master vorhanden sind, stellt ein Protokoll sicher, dass sich diese nicht gegenseitig stören.

=== I2C - Übertragungsraten ===
Die Übertragungsrate beträgt beim standard mode bis zu 100 kbit/s, beim fast mode bis zu 400 kbit/s und beim high-speed mode bis zu 3,4 MBit/s. Falls die Taktrate für einen Slave zu hoch ist, kann er die Clock-Leitung auf Null ziehen und die Übertragung damit verlangsamen. Dies ist auf Bit- wie auf Byte-Ebene möglich; ersteres allerdings nicht im high-speed mode.
Um längere Übertragungswege zu realisieren, kann man die Taktrate fast beliebig vermindern (einige Bausteine erzeugen aber irgendwann ein Time-Out). Mit einer Taktfrequenz von nur 5 kbit/s können dann durchaus mehrere Meter überbrückt werden.

Im PC wird ein dem I²C-Bus sehr ähnliches System benutzt, um z. B. die Daten eines [[SDRAM]]-Modules auszulesen. Dieser nennt sich [[SMBus]] (System Management Bus).

Erfahrungen mit den Atmegas (gemessene I2C-Taktfrequenzen):
* 16,000MHz - schafft sauber bis zu 700KHz
* 18,432MHz - schafft sauber bis zu 950KHz

Selbst unter schlechten Bedingungen wie...
* 50cm 6-adriges Spiralkabel, frei schwingend verbaut in einem Rennwagen als Verbindung zwischen Lenkraddisplay und Amaturenbrett
* Nähe zu nicht geschirmten Leitungen mit 12V, GND und 5V PWM zum Dimmen von LEDs
* grausamen Umgebungsgedingungen, Fahrten im Regen, Schnee oder bei glühender Sonne und gefühlten 100° C ;-) auf der Rennstrecke.
hat der Bus ohne Probleme funktioniert.

=== Bausteine ===

Neben Mikrocontrollern gibt es eine Reihe von Peripheriebausteinen, die per I²C angeschlossen werden können. Eine gute Anlaufstelle bei der Suche ist die unten angegebene Seite des "Erfinders" Philips, heute als [http://www.nxp.com NXP] bekannt.

*serielle [[Speicher#EEPROM | EEPROM]]s
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?text=24C01&action=Search 24Cxx]
** [http://ics.nxp.com/products/pcf/seeproms/ PCF85xx von NXP, 256-2048 Byte]

*I/O-Portexpander
** [[I2C-Schaltmodul|PCF8574]]
** MCP23008 (8-bit) von Microchip
** MCP23017 (16-bit) von Microchip

* I2C MUX, zum Anschluss von ICs mit gleicher, fester Adresse
** [http://www.datasheetcatalog.org/cgi-bin/helo.pl?field=Nume&type=C&text=PCA9545A&producedby=&action=Search PCA9545A]

* [[AD-Wandler]]
** [http://www.mikrocontroller.net/topic/182614 12x12 Bit ADC MAX1238]
** [http://www.mikrocontroller.net/topic/182614 12x10 Bit ADC MAX1138]
** [http://www.maxim-ic.com/datasheet/index.mvp/id/1890 MAX127 und MAX128 von Maxim, 12bit x8, PDIP24+SSOP28]
** [http://www.jtronics.de/elektronik-boards/adc-8bit-max1038.html 12x8 Bit ADC MAX1038]

* [[DA-Wandler]]
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?field=Nume&type=C&text=TDA8444&producedby=&action=Search TDA8444, 8x6Bit]

* Uhrenbausteine
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?field=Nume&type=C&text=PCF8583&producedby=&action=Search PCF8583, mit 256 Bytes RAM]
** DS1307

* [[LCD]]-Treiber
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?field=Nume&type=C&text=PCF8577&producedby=&action=Search PCF8577, 2x32 Segmente]

* [[Temperatursensor|Temperatursensoren]]
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?text=DS1621&action=Search DS1621]
** [http://www.datasheetcatalog.net/cgi-bin/helo.pl?text=lm75&action=Search LM75]
** [http://www.sensirion.com/en/pdf/product_information/Datasheet-humidity-sensor-SHT21.pdf SHT21]
** TMP101 von TexasInstruments
** TMP175 von TI (mehr als 8 Bausteine im gleichen Bus möglich)

=== Galvanische Trennung ===
* http://www.analog.com/static/imported-files/application_notes/AN_913.pdf
* http://www.analog.com/en/interface/digital-isolators/products/index.html#Isolated_I2C_Isolators
* http://www.mikrocontroller.net/attachment/5670/Galvanische_Trennung_fuer_I2C-Bus.pdf
* http://www.esacademy.com/en/library/technical-articles-and-documents/miscellaneous/i2c-bus/frequently-asked-questions/i2c-faq.html
* http://www.mikrocontroller.net/topic/17425#125464

== Siehe auch ==
* [[AT91-TWI]]
* [[AVR TWI]]
* [[I2C als Hausbus]]
* Beitrag zu [http://www.mikrocontroller.net/topic/181115#1748880 I2C-Adressen] im Forum

== Weblinks ==
* [http://ics.nxp.com/interface/ NXP (ehemals Philips) Produktseite]
* [http://www.nxp.com/acrobat/usermanuals/UM10204_3.pdf I2C Spezifikation 3.0]
* [http://www.i2c-bus.org I²C FAQ, Einführung, Hintergrundinformationen]
* [http://www.robotikhardware.de/download/rn_pc_i2c.pdf robotikhardware.de]

=== Bibliotheken ===
* [http://www.jtronics.de/elektronik-avr/lib-i2ctwi-avr.html AVR TWI Slave]

===I²C-Interface===
* [http://www.mikrocontroller.net/topic/155136#1462320 Beitrag "i2c usb interface"]

===I²C-Monitor===
*http://realterm.sourceforge.net/#I2C%20Bus
*http://www.avrfreaks.net/index.php?module=FreaksTools&func=viewItem&item_id=411
* [http://www.telos.info/ConniiMM20 Connii MM 2.0 - I²C Monitor with USB Interface]
* [http://www.telos.info/traciixl20 Tracii XL - High-End I²C Monitor]
*http://i2cchip.com/
* [http://www.ullihome.de/index.php/Hauptseite#USB_AVR-Lab I2C Logger Firmware für USB AVR-ISP]
* [http://www.mikrocontroller.net/topic/41535 I2C Monitor mit Mega8 (Firmware)]
* [http://warmcat.com/milksop/cheapi2c.html Cheapi2c] by Numbnut (Andy Green) uses your PC CPU (Linux only!) and printer port to perform realtime snooping of a standard 100kHz I2C bus with 100% capture.
* [http://www.mikrocontroller.net/topic/103600#905495 I2C (TWI) Sniffer]. Basierend auf einem ATtiny85 mit Ausgabe auf RS232 (C und ASM).
* [http://en.radzio.dxp.pl/i2c-sniffer/ I2C/TWI bus sniffer/analyzer] (ATTiny2313 @ 20 MHz und USB über FTDI FT245RL oder UM245R)
* [http://www.i2cchip.com/start_bit_detector1.jpg I2C Startbit-Detector] auf [http://www.i2cchip.com/ www.i2cchip.com]
* [http://www.harbaum.org/till/i2c_tiny_usb/index.shtml i2c-tiny-usb open source/open hardware zum Auslesen mit einem PC]

[[Category:I2C| ]]

AD-Wandler

2011-08-09T22:40:39Z

Kruemeltee: /* ADC I2C/TWI BUS */

Die Abkürzung AD-Wandler steht für einen Analog-Digital-Wandler (teilweise auch ADU, Analog-Digital-Umsetzer; im Englischen ADC Analog-Digital-Converter). Dieser wandelt eine [[analog|analoge]] Größe, meist eine Spannung, in einen [[digital|digitalen]] Wert um. Das Gegenstück ist der [[DA-Wandler]].

Die Auflösung mit der die analoge Größe gemessen wird bewegt sich zwischen 1 (Komparator) und 24 [[Digitaltechnik|Bit]]. Den durch die Wandlung entstehenden Fehler zwischen dem tatsächlichen Wert und dem ausgegebenen (gewandelten) Wert nennt man [[Quantisierung|Quantisierungsfehler]]. Er entsteht durch die unvermeidbare Rundung. Ferner entsteht durch die Nichtlinearität des Bauteils ebenfalls ein Fehler.

Der Wandlungsvorgang benötigt immer eine gewisse Zeit, während der die Eingangsgröße konstant bleiben muss. Das gilt auch für den Flash-ADC, da nicht alle Komparatoren gleich schnell sind. Hierfür werden sogenannte 'Track and Hold' bzw. 'Sample and Hold' Schaltungen verwendet, welche das Eingangssignal "einfrieren" während die AD-Wandlung läuft.

== Verfahren ==

* '''Flash'''- oder Parallel-Wandler verwenden für jeden Ausgangswert einen Komparator. Dadurch sind sie sehr schnell, aber auch teuer und stromhungrig. Flash-Wandler werden unter anderem in [[Oszilloskop#Digitale Oszilloskope|Digitalen Oszilloskopen]] eingesetzt.
* '''Sukzessive Approximation (SAR)''': Stufenweise Annäherung, Wägeverfahren. Benötigt einen [[DA-Wandler]], mit dem man sich Bit für Bit an die zu messende Spannung herantastet.
** Der interne AD-Wandler eines [[AVR]] verwendet diese Methode
* '''Single Slope, Dual Slope''' Verfahren: Werden meist in Multimetern oder ähnlichen Messgeräten verwendet da sie billig sind, wenig Strom brauchen und gute Linearitäten besitzen. Im Prinzip wird hier die Spannungsmessung über eine Zeitmessung realisiert (Zeitmessung des Auf- und Entladen eines Kondensators).
* '''Delta Sigma''': Vor allem für sehr genaue Messungen (24 Bit). Preisgünstig herstellbar, da nur ein Komparator und Logik-Elemente benötigt werden, dafür recht langsam. Werden vor allem im Audio-Bereich eingesetzt.
* '''Spannungs-Frequenz-Umsetzer''': Hier steuert die Eingangsspannung einen Oszillator, dessen Ausgangsfrequenz möglichst linear von der Eingangsspannung abhängt (Frequenzmodulation).
* '''Nachlauf-Verfahren''': Es wird auch hier ein DAC benötigt, der von einem Auf-Abwärtszähler gesteuert wird. Ein Komparator steuert ob auf- oder abwärts gezählt wird.

== Kenngrößen ==

Als Kenngrößen gibt es bei einem ADC bedeutend mehr als nur die [[Auflösung und Genauigkeit | Auflösung]]. Z.B. wäre es nicht schlecht, wenn er keine sogenannten 'Missing-Codes' hätte. Hier fehlen einfach gewisse Ausgangswerte, die Kennline hat Sprünge.

Weiters wichtig ist die Linearität. Es kann sein, dass die Kennlinie nichtlinear ist (Kennlinie Ausgangscode-Eingangsspannung gebogen) oder aber die einzelnen Stufen sind nicht gleich groß.

Außerdem wichtig sind Eingangsrauschen, Samplingzeit und Stromverbrauch.

==Praxis==

=== Große Spannungen messen ===

Will man einen AD-Wandler dazu nutzen große Spannungen zu messen, so behilft man sich mit einem [[Spannungsteiler]] nach Masse. So wird erreicht, dass die maximale Eingangsspannung bzw. Referenzspannung des AD-Wandlers nicht überschritten werden. Über das bekannte Widerstandsverhältnis kann dann per Software vom AD-Wert auf die gemessene Spannung zurückgeschlossen werden.

=== Negative Spannungen messen ===

Will man nun negative Spannungen messen, steht man vor dem Problem, den AD-Wandler keinen negativen Spannungen aussetzen zu dürfen. Hier hilft auch ein [[Spannungsteiler]] nach Masse nicht weiter. Es ist jedoch genausogut möglich, einen Spannungsteiler auf eine positive Spannung, z. B. die Betriebsspannung des AD-Wandlers zu beziehen. Um verlässliche Messwerte zu erhalten, darf die Bezugsspannung nicht schwanken, sollte also z. B. von einem Spannungsregler oder besser noch von einer [[Spannungsreferenz]] wie z. B. LM336 erzeugt werden.

<pre>
Vcc
---
|
+-+
| | R1
+-+
|
+---o Uadc
|
+-+
| | R2
+-+
|
Uin- o---+
</pre>

<math>\mathrm{U_{adc}=(V_{CC}-U_{in-}) \cdot \frac{R_2}{R_1+R_2} + U_{in-}}</math>

<math>\mathrm{U_{in-}=\frac{U_{adc}-V_{CC} \cdot \frac{R_2}{R_1+R_2}}{1-\frac{R_2}{R_1+R_2}}}</math>

Bei differentieller Messung sind Bezugsspannugsschwankungen theoretisch kein Problem, praktisch bildet man aber eine Art Wheatstone-Brücke nach, sodass durch die Toleranzen der Widerstände große Abweichungen auftreten können, wenn sich die Bezugsspannung ändert (z. B. Batteriebetrieb).

Siehe auch im Forum:
*[http://www.mikrocontroller.net/forum/read-1-173727.html Mit AD-Wandler negative Spannungen messen]
*[http://www.mikrocontroller.net/topic/78480 Vcc gegen interne Referenz messen] (AVR)
*[http://www.mikrocontroller.net/topic/214334?goto=2131995#2131984 Forumsbeitrag]: Berechung der Auflösung und des Messwerts, immer <math>\frac{1}{2^n}</math> und nicht <math>\frac{1}{2^n-1}</math>

=== Wechselspannung mit AC-Kopplung messen ===

In manchen Fällen, zum Beispiel bei Audio-Signalen, interessiert man sich nicht für den Gleichspannungsanteil (DC), sondern nur für den Wechselspannungsanteil (AC) eines Signals. In diesem Fall kann man durch einen Kondensator in Reihe eine sogenannte AC-Kopplung herstellen. Näheres dazu im Beitrag [http://www.mikrocontroller.net/topic/90989#new AC Kopplung wie groß muss der Kondesator sein?].

=== Genaues Messen und Fixed-Point Arithmetik ===

Siehe Forumsbeitrag [http://www.mikrocontroller.net/topic/170454#1630106 ADC und Fixed-Point Arithmetik] von Bernd N. und den Artikel [[Festkommaarithmetik]].

Zitierte Appnotes:
* [http://www.atmel.com/dyn/resources/prod_documents/doc2559.pdf AVR120: Characterization and Calibration of the ADC on an AVR] (PDF)
* [http://www.atmel.com/dyn/resources/prod_documents/doc8003.pdf AVR121: Enhancing ADC resolution by oversampling] (PDF)

== Externe AD-Wandler Bausteine ==
=== ADC I2C/TWI BUS ===
* [http://www.mikrocontroller.net/topic/182614 12x12 Bit ADC MAX1238]
* [http://www.mikrocontroller.net/topic/182614 12x10 Bit ADC MAX1138]
* [http://www.jtronics.de/elektronik-boards/adc-8bit-max1038.html 12x8 Bit ADC MAX1038]
* [http://www.maxim-ic.com/datasheet/index.mvp/id/1890 8 x 12bit ADC MAX127]

=== ADC SPI BUS ===
* 1x8 Bit TLC549
* 1x22 Bit MCP3351

=== ADC UART BUS ===
*

=== ADC CAN BUS ===
*

== Weblinks ==

* [http://www.tu-ilmenau.de/fakia/Interfacetechnik.5279.0.html Vorlesung Interfacetechnik] von Dr.-Ing. Norbert Hirt an der TU Ilmenau
* [http://focus.ti.com/docs/toolsw/folders/print/adcpro.html Simulationssoftware für AD Wandler]

[[Category:Bauteile]]
* [http://www.embedded.com/design/212101523 The ABC's of A-D converter latency] by Bonnie Baker, Texas Instruments (via Embedded.com)
* [http://www.embedded.com/design/multicore/217700911?printable=true Writing software drivers for analog to digital converters], By Mark Thoren and Leo Chen, Linear Technology Corp., Embedded.com, ([[I2C]])

Datei:I2ctools avr32 grasshopper ngw100 stk1000.tar.bz2

2011-08-03T20:17:44Z

Kruemeltee:

Benutzer:Kruemeltee

2011-08-03T20:17:25Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei meiner Seite */

== '''Schaut doch mal hier vorbei [[Mini2440]] und bei [http://krumeltee.wordpress.com/ meiner Seite]''' ==

[[Datei:i2ctools_avr32_grasshopper_ngw100_stk1000.tar.bz2]] i2ctools (i2cdetect, i2cdump, i2cget, i2cset) compiliert für AVR32-Linux (Grasshopper, NGW100, STK1000).

[http://www.mikrocontroller.net/attachment/highlight/54535] SDCC Header File für den Controller '''T89C51AC3''' von Atmel.

Benutzer:Kruemeltee

2011-08-02T18:45:58Z

Kruemeltee: /* Schaut doch mal hier vorbei Mini2440 und bei MPD Client Programming */

== '''Schaut doch mal hier vorbei [[Mini2440]] und bei [http://krumeltee.wordpress.com/ meiner Seite]''' ==

[http://www.mikrocontroller.net/attachment/highlight/54535] SDCC Header File für den Controller '''T89C51AC3''' von Atmel.

Sinus Tabelle

2011-07-24T11:19:32Z

Kruemeltee: Die Seite wurde neu angelegt: „''von kruemeltee'' Da die Sinusberechnung auf einem Mikrocontroller sehr zeitintensiv ist, kann man in vielen Fällen auch mit einer fest…“

''von [[Benutzer:kruemeltee|kruemeltee]]''

Da die Sinusberechnung auf einem Mikrocontroller sehr zeitintensiv ist, kann man in vielen Fällen auch mit einer festen Sinustabelle arbeiten, aus welcher die Werte geholt werden.

Natürlich lässt sich dieses Prinzip analog auch für Cosinus, Tangens, usw. verwenden.

Hier ein Beispiel in C, welches eine kleine Sinustabelle im Programspace hält, die Werte ausliest und auf einem Display ausgibt.
Dieses Beispiel gibt die Werte auf dem Display mit der Fleury-Display-Library aus.

<c>
#include <avr/io.h>
#include <stdio.h>
#include <avr/pgmspace.h>
#include "lcd.h"

float sine_table_16_entries[16] PROGMEM = {
0.00000,
0.38268,
0.70711,
0.92388,
1.00000,
0.92388,
0.70711,
0.38268,
0.00000,
-0.38268,
-0.70711,
-0.92388,
-1.00000,
-0.92388,
-0.70711,
-0.38268
};

int main() {
lcd_init(LCD_DISP_ON);
lcd_clrscr();

sprintf(buffer, "%f", pgm_read_float(&sine_table_16_entries[3]));
lcd_gotoxy(0,0);
lcd_puts(buffer);

for(;;);
}
</c>

Zum Erstellen einer Sinustabelle wie im obigen Beispiel habe ich ein kleines Programm geschrieben, welches ein Headerfile mit einer Sinustabelle in beliebiger Grösse erzeugt.

Das Programm lässt sich hier herunterladen: [[Datei:sintab.zip]]

Hier ist der Quellcode dazu:

<c>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main() {
FILE *fp;
char buffer[256];
double sine, sine_base = 0.0;
int x = 0;
int steps;

printf("Anzahl der gewuenschten Eintraege: ");
scanf("%d", &steps);

fp = fopen("sine_table.h", "w");

sprintf(buffer, "#ifndef __SINE_TABLE_H__\n#define __SINE_TABLE_H__\n\ndouble sine_table_%d_entries[%d] = {\n", steps, steps);
fputs(buffer, fp);

while(x < steps) {
sine = sin(sine_base);
if(x != steps-1) sprintf(buffer, " %0.5f,\n", sine);
else sprintf(buffer, " %0.5f\n", sine);
fputs(buffer, fp);
sine_base += ((2.0*M_PI)/steps);
x++;
}

fputs("};\n\n#endif\n", fp);
fclose(fp);
printf("Sinustabelle mit %d Eintraegen erzeugt (sine_table.h)!\n", steps);
system("PAUSE");
return 0;
}
</c>

Datei:Sintab.zip

2011-07-24T11:18:53Z

Kruemeltee: Programm zum erstellen eines Headerfiles für AVR-GCC mit einer Sinustabelle in beliebiger Grösse.

Programm zum erstellen eines Headerfiles für AVR-GCC mit einer Sinustabelle in beliebiger Grösse.

Mini2440

2011-06-09T11:19:29Z

Kruemeltee: /* Verbindung zum PC */

[http://www.friendlyarm.net/products/mini2440 Mini2440 von friendlyarm ]

Das [[Mini2440]] ist ein [[ARM]]-Board mit [http://www.samsung.com/global/business/semiconductor/productInfo.do?fmly_id=229&partnum=S3C2440&ppmi=PartnoSearch s3c2440] '''S'''ystem '''o'''n '''C'''hip von Samsung.

Das '''Board''' bietet:
* 3,5", 7" Touchscreen-[[TFT]] oder [[VGA]] "Karte"
* ARM920T, 400Mhz standard Taktfrequenz, bis zu 533Mhz
* 64MB-1GB NAND Flash (User App/OS), 2MB NOR Flash (BIOS)
* 64MB RAM
* Audio (Stereo Out, 2xMono In)
* SD-Slot
* [[USB]] Host, USB Device
* 10/100MBit LAN (DM9000)
* 3 Serial Ports
* [[SPI]], [[PWM]], [[I2C]], ...
* ...

[[Bild:mini2440.jpg|300px]][[Bild:mini2440_35.jpg|300px]][[Bild:mini2440_7.jpg|300px]]

== Software ==

Als das passende Entwicklungswerkzeug ist ein Linux-Rechner mit passendem Cross-Compiler sowie ein paar Tools vorgesehen.
Was wirklich benötigt wird:
* Serial Terminal (picocom, minicom, cutecom, gtkterm, komport, ...)
* [http://www.mikrocontroller.net/articles/Mini2440#Toolchain Toolchain]
* s3c_boot_usb oder [http://programmers-projects.de/node/16 mini2440_usb_upload] (aktueller; mit Status-Anzeige etc.) zum Hochladen von Bootloader, Kernel etc. über USB

Empfehlenswert ausserdem noch:
* ncurses-dev-Dateien und dialog (Für Kernel-menuconfig)
* screen, midnight commander
* Editor mit root-Rechten (z.B. [http://home.in.tum.de/~lazarov/files/research/papers/vi_ausarbeitung.pdf vim])

=== Vorbereitungen am/mit dem Board ===

Ganz wichtig ist es, eine gute Spannungsversorgung zu verwenden. Es kam anscheinend schon öfter vor, dass kleine Spannungseinbrüche das Board aus dem Gleichgewicht bringen.
Ich verwende normalerweise das mitgelieferte Netzteil oder ein '''5V'''/'''2A''' Schaltnetzteil, funktionieren beide einwandfrei.
Gerade das grosse, 7", Display braucht ein starkes Netzteil.

{| class="wikitable"
|+ '''ungefährer Stromverbrauch'''
|-
! Board konfig. || Stromverbrauch
|-
| mini2440 || 140mA
|-
| mini2440 + 3,5" TFT || 410mA (T35 Display)
|-
| mini2440 + 7" TFT || 1000mA
|-
| mini2440 + VGA Board || mA
|}

==== Verbindung zum PC ====

Um vernünftig arbeiten zu können, braucht man auf jeden Fall diese Kabel:
* 1 USB A<->USB B-Kabel
* 1 9 poliges SUB-D Kabel mit zwei Buchsen
* eventuell einen USB-RS232 Adapter, falls man keinen Anschluss am Rechner hat

Einen Zugriff auf die Konsole hat man - nach Anpassung der IP - über Telnet sowie über die serielle Konsole.

Die serielle Konsole ist in der Standardkonfiguration aktiviert und '''sollte''' auch während des Entwickelns '''immer aktiv''' sein - so verhindert man ein ungewolltes Ausperren.

==== Netzwerk ====
Entweder klickt man sich quer durch die chinesische/japanische Software und stellt diese auf Englisch um, oder aber man klickt sich blind zu der Stelle, an der man IP Adresse, Gateway und Netzmaske angeben kann.

Etwa genauso einfach sieht es über die Konsole aus. 
Die folgenden drei Zeilen, dürften das soweit bewekstelligen, dass das Netzwerk-Device die IP-Adresse '''192.168.0.55''', die Netzmaske '''255.255.255.0''' zugeteilt bekommt. Die beiden anderen Anweisungen sagen dem System, welches Netzwerkgerät der Router ist. In diesem Fall '''192.168.0.1'''.

Es ist darauf zu achten, was bisher vielleicht schon in der ''/etc/resolv.conf'' steht. Das lässt sich einfach mit ''cat /etc/resolv.conf'' ansehen. Wenn diese bereits den richtigen Inhalt hat, kann man die ''echo "nam...''-Anweisung weglassen. 
Wenn die resolv.conf nicht existiert oder einen falschen Wert enthält, '''überschreibt''' man diese, in dem man nur '''ein''' "''>''" nach das echo setzt. Stehen dort zwei "''>''" wird die nameserver-Info nur an die Datei angehängt und es kann zu Problemen kommen.

<pre> $ ifconfig eth0 192.168.0.55 netmask 255.255.255.0
$ route add default gw 192.168.0.1
$ echo "nameserver 192.168.0.1" > /etc/resolv.conf
</pre>

==== Benutzeraccounts ====

Linux legt wie alle Unix-artigen Betriebssysteme sehr grossen Wert auf eine ordentliche Benutzer- und Rechteverwaltung. 
Daher sollte man sich überlegen, ob es nicht vielleicht besser wäre, wenn man einen extra Benutzer zum Arbeiten/Basteln/Produktiv-Sein/Bier-Trinken/... anlegt. 
Wenn nicht unbedingt nötig, sollte man auf das Arbeiten als '''root''' (oder auch Superuser, Admin, ...) verzichten. Dadurch dass man uneingeschränkt '''alle''' Rechte auf dem System besitzt kann es durch Programmierfehler oder auch Schadsoftware zu ernsthaften Schäden kommen (Datenverlust, eventuell Hardwareschäden). 
Die Entscheidung ob man wirklich root sein muss, ist eigentlich relativ einfach. Sie wird normalerweise '''immer''' erstmal mit '''nein''' beantwortet. Sollte sich im Lauf der Zeit doch herausstellen, dass man root sein muss, kann man diesen Weg immer noch einschlagen. 
Für einige Aufgaben sind jedoch auch root-Rechte erforderlich.
Zum Beispiel, wenn man direkt mit outporb()/inportb()/outb()/inb()/... arbeiten will. 
Für diese Fälle gibt es ein gutes Tool, es nennt sich [http://de.wikipedia.org/wiki/Sudo sudo].
Man kann sudo z. B. sagen, dass Benutzer ''xy'' das Programm /usr/bin/blubb mit root-Rechten immer ausführen darf. Benutzer ''ab'' darf das aber nur, wenn er '''sein''' Passwort eingibt. Dann gibt es vielleicht noch Benutzer ''zz'', der alles ohne Passwort als root ausführen darf.

===== Anlegen eines neuen Benutzeraccounts =====
Ich gehe davon aus, dass ein Image mit busybox auf dem Board installiert ist. Wenn das Image von FriendlyARM installiert ist, ist das der Fall.

Ein Auszug aus der [http://linux.die.net/man/1/busybox Manpage] von busybox:
<pre>adduser
adduser [ OPTIONS ] user_name

Adds a user to the system

Options:

-h DIR Assign home directory DIR
-g GECOS Assign gecos field GECOS
-s SHELL Assign login shell SHELL
-G Add the user to existing group GROUP
-S create a system user (ignored)
-D Do not assign a password (logins still possible via ssh)
-H Do not create the home directory

</pre>

Heisst um einen Benutzer ''banana_joe'' mit dem Heimatverzeichnis ''/home/banana_joe'' anzulegen, muss man folgendes '''als root''' eingeben:
<pre> $ adduser -h /home/banana_joe -s /bin/sh banana_joe
$ passwd banana_joe
</pre>
''adduser'' legt den Benutzer an, ''passwd'' vergibt ein Passwort.

=== Übertragen von Daten/Programmen in den Flash-Speicher ===

Das übertragen gestaltet sich auf ganz unterschiedliche Weise. Aus Gründen der Einfachheit werde ich hier nur die sinnvollsten/einfachsten/schnellsten Wege beschreiben. Andere Möglichkeiten wären noch ''lrzsz'', USB und [[JTAG]].
Wer zuviel Zeit hat, kann sich ja auch ein eigenes Protokoll auf TCP/IP Ebene basteln oder den Kristallspeicher erfinden ;)

Wenn man eine Datei übertragen hat, muss man sich vergewissern, dass diese auch Ausführrechte besitzt, wenn sie ein Programm oder ein Ordner ist. Die Lese- und Schreibrechte müssen ebenfalls richtig gesetzt sein.
Normalerweise stimmt dies alles so wie es ist, aber manchmal muss man ein wenig nachhelfen.
Wenn sich ein Programm nicht ausführen lässt, oder man nicht in einen Ordner wechseln kann, fehlen die Rechte zum Ausführen. Geändert wird das so:
<pre> $ chmod +x <datei/ordner></pre>
Da hier aber nicht die Unix-Rechte erklärt werden sollen, verweise ich [http://linuxwiki.de/DateiRechte hierauf]

==== http ====
Für diese Methode muss natürlich das [http://www.mikrocontroller.net/articles/Mini2440#Netzwerk Netzwerk] eingerichtet sein. Man braucht auf einem PC im Netz einen laufenden Werbserver, auf den man die zu übertragenden Dateien legt.
Nun kann man diese in ein Verzeichnis seiner Wahl "herunterladen":
<pre> $ cd /tmp
$ wget http://10.2.5.29/datei
</pre>

==== ftp ====
Sobald auf dem Board ein FTP-Server läuft, kann man sich "ganz normal" mit einem FTP-Client (zum Beispiel '''gftp''' oder '''ncftp''') verbinden und die Dateien hochladen.
Ebenso kann man sich auch vom Board auf einen FTP-Server verbinden.
Nennenswerte Programme sind z.B. '''ftp''' für die Linux-Konsole, welches im FriendlyARM Image bereits enthalten ist oder der ncurses-basierende Client '''ncftp'''. Allerdings sollte man sich für ncurses-Programme per Telnet oder SSH einloggen, da die serielle Konsole nur rudimentäre Terminal-Emulation unterstützt und die Bildschirmausgabe nicht gerade schön wirkt.

==== scp/ssh ====
Dazu muss zuerst einmal ein SSH Server auf dem Board laufen.
[http://www.openssh.com openSSH] ist dafür die erste Wahl. Mit [http://matt.ucc.asn.au/dropbear/dropbear.html dropbear] gibt es einige Probleme, da man für SCP auch noch die SCP Binary von openSSH braucht.

Sobald der ssh server läuft, ist alles ganz einfach:
<pre>$ scp datei user@ziel:/pfad</pre>
Bei einem Board mit der IP 10.0.0.69 und dem User ''root'' wäre das die Befehlszeile:
<pre>$ scp datei root@10.0.0.69:/root</pre>
... und die Datei ''datei'' landet im Heimatverzeichnis von ''root''

Um nicht jedes mal das Passwort eingeben zu müssen, lohnt es sich SSH so zu konfigurieren, dass es mit [http://wiki.unixboard.de/index.php/SSH_ohne_Passwort Key-Files] läuft.

=== Toolchain ===
Toolchains gibt es im Netz und auf der CD/DVD zum Board mehrere fertig übersetzte - natürlich lässt sich die Toolchain auch selbst compilieren.
Das Risiko beim selbst compilieren einer Toolchain liegt darin, dass man eventuell einen fehlerhaften Compiler produziert.
Gründe hierfür sind z.B.:
* fehlende, wichtige Patches
* Verwenden von Entwicklerversionen mit eventuellen Bugs
* ein schon fehlerhafter Host-Compiler
* falsche Einstellungen (Prozessor-Architektur, Optimierung, ...)
 
Das sogenannte Bootstrappen eines Compilers erkennt solche Probleme in den meisten Fällen. Bootstrappen heißt, dass zuerst mit dem Host-Compiler der Quellcode des neuen übersetzt wird und mit diesem zweiten Compiler wird ein dritter Compiler übersetzt. Wenn dies klappt, kann man im Normalfall davon ausgehen, dass der dritte Compiler in Ordnung ist. 
Jedoch ist dies bei einem Crosscompiler so nicht möglich, da der zweite Compiler ja keinen Code für den Host-Computer, sondern nur für das Target produzieren kann. Somit würde man sich einen Compiler für das Board bauen. 
Wer auf Nummer sicher gehen will, nimmt am besten eine der bekannten ARM-Toolchains oder natürlich die von FriendlyARM.

==== old ABI / new EABI ? ====

'''ABI''' steht für '''''A'''pplication '''B'''inary '''I'''nterface'', also eine Art "Standard" wie das compilierte Programm, die Binärdatei, auszusehen hat.

Die ABI ist schon etwas älter und wurde von der EABI ('''''E'''mbedded '''A'''pplication '''B'''inary '''I'''nterface'') abgelöst.

Da nahezu jede verfügbare Toolchain auf der EABI aufbaut, würde ich diese auch nutzen. Alte, für die ABI, compilierte Programme, lassen sich mit der Kernel-Unterstützung zum Ausführen von ABI Programmen trotzdem noch verwenden.

Durch das verwenden der EABI entstehen normalerweise keine unüberwindbaren Hürden, beim compilieren von älteren Quellcodes. Jedenfalls nicht durch den Unterschied ABI/EABI.

==== Kernel FPE / softfloat ? ====

Irgendwann stolpert jeder, der mit ARM-CPUs und Linux arbeitet über mehrere Fragen.
* Was ist softfloat/FPE?
* Was ist schneller?
* Kann man beides nutzen?

'''Was ist softfloat/FPE''' 
Dadurch, dass eine ARM-CPU normalerweile keine [http://de.wikipedia.org/wiki/Gleitkommaeinheit Gleitkommaeinheit/FPU] besitzt, müssen alle Berechnungen, welche Kommazahlen enthalten in Software gelöst werden. Bei einem PC-System übernimmt diese Aufgabe eben die FPU und ist somit um einiges schneller. 
''softfloat'' ist die Umsetzung durch den Compiler. 
''FPE'' bedeutet '''''F'''loating '''P'''oint '''E'''mulation'' und wird durch den Kernel bereit gestellt. 

'''Was ist schneller''' 
Beim FPE-Verfahren wird der Code, welcher die Gleitkomma-Anweisungen enthält auch so übersetzt. Da die CPU aber keine [http://de.wikipedia.org/wiki/Gleitkommaeinheit FPU] besitzt und somit auch keine Maschinensprachen-Befehle dafür, wird eine ''Exception'' ausgelöst ("Fehler"), welche vom Kernel abgefangen wird. 
Nun steht der Kernel vor der Aufgabe, die Gleitkomma-Operation zu lösen und dem Programm das Ergebnis mitzuteilen. Danach muss er den Code für die Exception noch zu Ende führen und zurückkehren. 
Alles in allem eine sehr aufwendige Methode.

Da bei ''softfloat'' die Gleitkomma-Operationen vom Compiler soweit zerstückelt und wieder zusammengesetzt werden, dass gar keine Kommas mehr nötig sind, ist das in dem meisten Fällen flotter.

Das schnellste, ist natürlich eine Hardware-[http://de.wikipedia.org/wiki/Gleitkommaeinheit FPU], die es aber auf dem [[mini2440]] nicht gibt.

'''Kann man beides nutzen?''' 
Jein, wenn man im Kernel eine der beiden FPE-Methoden aktiviert hat und man führt ein softfloat-Programm aus, dann wird natürlich softfloat verwendet.
Wenn man allerdings ein FPE-Programm ausführen will und hat die Unterstützung nicht im Kernel, sieht es schlecht aus.

Also am besten eine FPE auswählen und mit einer softfloat-Toolchain compilieren. Das spart Zeit und Kopfzerbrechen über Invalid Opcode/Segfaults usw. ;)

==== Toolchain aufsetzen ====
Jenachdem, welche Toolchain man einsetzt, kann es sein, dass man den Compileraufruf anpassen muss.
Wenn man eine Cross Toolchain installiert hat und nur ''gcc'' auf der Kommandozeile eintippt, wird man höchstwahrscheinlich beim ''lokalen'' gcc, keinem Cross-Compiler, landen. Überprüfen kann man das mit
<pre> $ which gcc</pre>
Die FriendlyARM Toolchain macht es uns da sehr leicht, sie verwendet aussagekräftige Namen für ihre Programme. Bei ihr wäre der gcc Aufruf der:
<pre> $ arm-linux-gcc
oder
$ arm-none-linux-gnueabi-gcc
</pre>
Ich gehe im kompletten Artikel davon aus, dass man eine funktionierende Toolchain installiert hat, welche über ''arm-linux-...'' zu erreichen ist. Entweder passt man die gcc-Aufrufe von hier an, oder man kann sich auch [http://wiki.unixboard.de/index.php/ManPage:ln symbolische Links] anlegen.
Zum Schluss sollte das dann ungefähr so aussehen, vom bin-Pfad der Toolchain aus!
<pre> $ ls -al /usr/local/arm/4.3.2/bin/
...
lrwxrwxrwx 1 root root 25 2010-02-25 07:15 arm-linux-ld -> arm-none-linux-gnueabi-ld
...
</pre>
Ich selbst arbeite mit der FriendlyARM-Toolchain, werde mich hier also meistens auf diese beziehen, ausser anders vermerkt.
===== FriendlyARM =====
[http://www.friendlyarm.net/downloads Hier] als ''ARM-Linux-GCC'' zu finden.

Entpackt verbraucht diese Toolchain ca. 295MB. Mit ihr liessen sich bei mir bereits der Kernel, uboot, sowie zahlreiche Programme kompilieren.

Zuerst wird die Toolchain an die richtige Stelle entpackt, der Pfad mit angegeben und dann ist sie auch schon bereit.
Dieses Kommando sieht auf den ersten Blick etwas nach Dateisystem-Apokalypse aus, ist allerdings lage nicht so wild. Die Option ''-C /'' sagt, dass direkt ins Wurzelverzeichnis entpackt werden soll, daher benötigt man für diesen Schritt '''root-Rechte'''. Die FriendlyARM-Toolchain ist so aufgebaut, dass sie damit nach ''/usr/local/arm/4.3.2/'' entpackt wird, '''unser Ziel''' :)
<pre> $ tar xvfj arm-linux-gcc-4.3.2.tar.gz -C /
</pre>
Wenn wir das nun so haben, müssen wir natürlich auch noch sagen, wo er den Compiler findet.
Dazu öffnet man am besten seine "autorun-Datei" der Shell. In der Konsole ganz einfach mit vim/nano/etc zu erreichen.
<pre> $ vim /home/user/.bashrc</pre>
Dort tragen wir dann '''ganz ans Ende''' dies ein:
<pre>export PATH=$PATH:/usr/local/arm/4.3.2/bin</pre>
Kaum gespeichert, startet man eine neue shell (Konsole) und überprüft ob die Pfade stimmen.
Wenn ''/usr/local/arm/...'' im Pfad enthalten ist, müsste alles stimmen.
<pre> $ echo $PATH</pre>
Tippt man nun '''nur''' ''arm-'' und drückt zweimal die Tabtaste, so müsste eine ellenlange Liste mit Programmen wie z. B. ''arm-linux-gcc'' oder ''arm-linux-ld'' erscheinen.
<pre> $ arm-linux-gcc -v</pre>

===== codesourcery =====
[http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 codesourcery arm-none-linux-gnueabi]

===== buildroot =====

Von http://www.buildroot.net das letzte stable Release holen, mini-2440 wird unterstützt. Der Build dauert zwar einige Zeit, aber nacher kann man sich an X11 erfreuen.

=== Cross Compiling ===
Sobald die Toolchain richtig aufgesetzt ist kann man anfangen, seine Programme zu übersetzten.

Hier folgt nur eine kurze Beschreibung, wer sowas genauer wissen will, sollte sich auf Seiten wie diesen umsehen:
* http://www.ailis.de/~k/archives/19-ARM-cross-compiling-howto.html
* http://linux.bytesex.org/cross-compiler.html
Ausserdem findet man zu vielen embedded-nutzbaren Programmen direkt ein Cross-Compiling Howto mit ein wenig google.
Ob diese nun für ARM, AVR32, PPC, MIPS, ... sind, ist im Grunde egal, da man ja meistens nur die Architektur anpassen muss.

Es gibt mehrere Möglichkeiten. Die erste ist der direkte Aufruf vom Compiler oder mittels eines "festen" Makefiles. Die zweite, wahrscheinlich Häufigste, ist das ausführen eines configure-Scriptes bevor der make-Vorgang gestartet wird.

* Das einfache aufrufen des Compilers
Dazu ein einfaches Hello-World Programm:
<c>
#include <stdio.h>

int main() {
printf("hiho\n");
}
</c>

Compiliert wird das Programm ganz einfach so:
<pre>$ arm-linux-gcc <name.c> -o <name></pre>
Danach wird die Datei ''<name>'' an das Board [http://www.mikrocontroller.net/wikisoftware/index.php?title=Mini2440&action=submit#.C3.9Cbertragen_von_Daten.2FProgrammen_ins_Flash übertragen].
Sobald ''<name>'' auf dem Board ist, kann es ausgeführt werden:
<pre> $ ./<name></pre>
Eventuell fehlen die Rechte:
<pre> $ chmod +x <name></pre>

* ./configure-Scripte
Hier sieht es schon ein klein wenig schwieriger aus, ist es aber eigentlich nicht.
''Normalerweise'', aber '''nicht immer''', sieht das compilieren eines Programms für das mini2440 so aus:
<pre> $ HOST=arm-linux ARCH=arm ./configure --build=arm-linux --your-options
$ make
</pre>
Man muss dem configure-Script lediglich angeben, für welche Architektur das Makefile konfiguriert werden soll und welchen Compiler er dafür nehmen soll.

=== Linux-Kernel ===

Den Kernel-Quellcode besorgt man sich am besten den Kernel-Fork von buserror. Wenn man nicht auf dem ARM selber kompilieren möchte, benutzt man wie hier im Beispiel einen Cross-Compiler (Siehe oben). Weiterhin wird noch git benötigt, um den Kernel-Quellcode zu laden. Folgende Einstellungen werden im Abschnitt verwendet:
<pre> Verzeichnis: /mnt/mini2440
CHOST/CROSS-COMPILE: arm-softfloat-linux-gnueabi
</pre>
Starten wir damit, den Quellcode zu laden:
<pre> $ cd /mnt/mini2440
$ git clone git://repo.or.cz/linux-2.6/mini2440.git linux-2.6.32-rc8</pre>
Dann ab ins Kernel-Verzeichnis und den Kernel mit den Defaults konfigurieren:
<pre> $ cd linux-2.6.32-rc8
$ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm make mini2440_defconfig</pre>
Wenn man noch etwas manuell ändern möchte:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm make menuconfig</pre>
Den Kernel anschließend kompilieren:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm make</pre>
Die Module bekommen wir wie folgt nach /mnt/mini2440/lib/modules installiert:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm INSTALL_MOD_PATH=/mnt/mini2440 make modules_install</pre>
Wenn wir mit u-boot arbeiten, dann benötigen wir das zImage in /mnt/mini2440/kernel-2.6.32-rc8/arch/arm/boot, um daraus mittels mkimage (Siehe uboot) ein uImage zu erstellen.
 
'''Kernel-Parameter''' 
dem Kernel kann man zum Start noch Parameter für das Board mitgeben:
<pre>mini2440=[0..9][t][b]</pre>
[0..9] bestimmen die Display-Timings (varieren je nach verwendetem Kernel)
* 0 3,5" Display N35 + TS (alt);
* 1 7" Display + TS;
* 2 VGA-Board;
* 3 3,5" Display T35 + TS;
* 4 5,6" Display Innolux + TS;
[t] Touchscreen ist vorhanden; 
[b] Backlight ist vorhanden;

=== root-fs ===
Um ein eigenes Root-Filesystem zu compilieren, gibt es mehrere Möglichkeiten.

Die einfachsten sind Cross-Umgebungen wie [http://buildroot.uclibc.org/ buildroot] und [http://wiki.openembedded.net/index.php/Main_Page openembedded].

==== Debian ====
Auch relativ einfach ist es, sich ein fertig compiliertes debian-arm zu installieren. Wenn man das Debian einmal auf seiner SD-Karte laufen hat, ist es kein Problem mehr, alles wie gewohnt mit apt zu installieren usw. usw. 
Allerdings sind gerade die Scripte bei Debian noch nie dafür bekannt gewesen sonderlich schnell zu laufen und es ist sehr sehr träge beim booten.

Ich habe auf meinem mini2440 seit einiger Zeit Debian am Laufen, habe aber sämtliche Init-Scripte durch eigene ersetzt, welche um einiges flotter laufen. Ebenso verzichte ich auf sysvinit und damit aber auch auf sehr nützliche Tools/Funktionen, wie die runlevels und shutdown oder reboot.
Diese Funktionen müssen auch von meinen eigenen Scripten übernommen werden. Dafür läuft es um einiges schneller.

[http://emqbit.com/deboostrap-debian Hier] eine Anleitung für ein AT91-Linux Board mit Debian. Diese kann fast 1:1 übernommen werden.

Mit X11, Lighttpd, PHP, Python, mc, vim, mpd, alsa, gcc, ... (und auch apache als leidige Abhängigkeit von PHP) braucht mein Debian etwa 550MB auf der SD-Karte.
Schon ein ordentlicher Brummer, aber egal, es bootet mit eigenen Scripten innerhalb von 15 Sekunden.

==== Gentoo ====
Ooooh wer daran denkt, hat einfach nur zuviel Zeit. Gentoo in allen Ehren, aber allein PHP zu compilieren dauert gut 4 Stunden... danach habe ich es aufgegeben.

Wer Gentoo installieren kann, wird sich auf dem Mini2440 auch nicht schwerer tun, als auf einem PC. Der Unterschied besteht nur darin, dass man die Stage auf SD Karte packen muss, am normalen Rechner natürlich, und dort dann schon die wichtigsten Einstellungen vornehmen muss.

Mit Portage und den ganzen Dev-Files ist Gentoo ein riesen Gebilde für so ein schwachbrüstiges Board. Eine 4GB SD-Karte ist das Minimum. Außer man bootet zuerst in den Flash und dann chrootet man auf ein Gentoo auf einer USB-Festplatte. uboot kann das, soweit ich weiß, nicht.

=== sys-fs ===
Sysfs ist ein virtuelles Dateisystem, welches seit dem Linux Kernel 2.6. zur Verfügung gestellt wurde. Der Kernel stellt dabei Konfigurationen, Informationen über Vorrichtungen und Treiber im sogenannten userspace zur Verfügung. Dies Bedeutet einfach, dass Informationen/Geräte an einer festgelegten Stelle im Dateisystem stehen und ausgelesen oder beschrieben werden können.

Über einige Dateien in diesem Dateisystem können GPIOs und z.B. auch LEDs angesteuert werden.

=== Framebuffer ===
Der Framebuffer ist von Haus aus im FriendlyARM Kernel aktiviert und ohne ihn lässt sich im Linux keine Ausgabe auf dem Display realisieren. Er ist unter ''/dev/fb0'' zu erreichen. 
In der Kernelkonfiguration muss die Framebuffer-Konsole und der Framebuffer-Treiber für das jeweilige Display gewählt werden.

Eine Textausgabe geht ganz einfach über das Terminal, welche auf ihn gemappt ist:
<pre>$ echo "hello world" > /dev/tty1</pre>

Man kann dem Framebuffer diverse Argumente mitgeben, die die Ausgabe auf dem Display beeinflussen. Diese werden über ''fbcon=...'' angeben. Man kann auch mehre Argumente angeben, das sähe zum Beispiel so aus:
<pre>
root=/dev/mmcblk0p1 console=ttySAC0 fbcon=rotate:1 fbcon=scrollback:0
</pre>

Alternativ können mehrere fbcon-Parameter auch durch Komma getrennt werden:
<pre>
... fbcon=rotate:1,scrollback:0
</pre>

Der Scrollback-Buffer ist auf diesem Display eigentlich nicht nötig, da man hier auf dem Mini2440 auf keiner Konsole mit Tastatur usw. arbeitet. Daher schaltet man ihn mit ''fbcon=scrollback:0'' ab, das spart gegenüber dem Standardwert 32kB RAM. 
Wer ihn doch benötigt, kann ihn natürlich trotzdem verwenden. Die Zahl nach dem Doppelpunkt steht für die Größe in Bytes. Ein ''k'' als Suffix steht für Kilobyte, ''fbcon=scrollback:1024k'' entspräche einem Scrollback-Buffer von 1MB.

Für die FB-Konsole gibt es einige weitere Möglichkeiten und viele Optionen lassen sich zur Laufzeit ändern. Hier habe ich nur das Wichtigste beschrieben. Wer darüber mehr erfahren will, sollte sich im Kernel-Quellcode die Datei ''Documentation/fb/fbcon.txt'' ansehen.

==== Font wählen ====
Die voreingestellte VGA8x16 Font ist etwas groß und es passt nicht allzuviel Text auf das Display. Die am besten lesbare, kleine Schrift ist die Mac6x11 Font.
In menuconfig folgendes einstellen:
<pre>
-> Device Drivers
-> Graphics support
-> Console display driver support
-> Select compiled-in fonts
<*> Framebuffer Console support
[*] Map the console to the primary display device
[*] Framebuffer Console Rotation
[*] Select compiled-in fonts
[ ] VGA 8x8 font
[ ] VGA 8x16 font
[*] Mac console 6x11 font (not supported by all drivers)
[ ] console 7x14 font (not supported by all drivers)
[ ] Pearl (old m68k) console 8x8 font
[ ] Acorn console 8x8 font
[ ] Mini 4x6 font
[ ] Sparc console 8x16 font
[ ] Sparc console 12x22 font (not supported by all drivers)
[ ] console 10x18 font (not supported by all drivers)
</pre>
Werden mehrere Fonts eincompiliert, können sie so ausgewählt werden:
<pre>
(Kernel-Commandline)
... fbcon=font:xxxx
</pre>
Mögliche Werte für ''xxxx'' sind:
* VGA8x8
* VGA8x16
* Mac6x11
* 7x14
* 10x18
* MINI4x6
* RomanLarge
* SUN8x16
* SUN12x22
* ProFont6x11
* Acorn8x8
* PEARL8x8

Bei machen Fonts steht in der Kernel-Menuconfig ''not supported by all drivers''. Dies erklärt sich so:
<pre>
Note, not all drivers can handle font with widths not divisible by 8,
such as vga16fb.
kernel-src/Documentation/fb/fbcon.txt
</pre>
Manche Treiber können nicht mit Fontbreiten/-höhen umgehen, welche nicht durch 8 teilbar sind. Da aber z.B. die MAC6x11 Font auch nicht durch 8 teilbar ist und das Mini2440 das anzeigen kann, gehe ich davon aus, dass alle funktionieren.

==== Rotation ====
Um das Display zu "drehen" folgendes einstellen:
<pre>
-> Device Drivers
-> Graphics support
-> Console display driver support
-> Framebuffer Console support
[*] Framebuffer Console Rotation
</pre>
Also Kernel-Parameter im Bootloader dann einstellen:
<pre>
fbcon=rotate:x
</pre>
Für ''x'' sind Werte von 0 bis 3 gültig. Jeweils wird um 90° im Uhrzeigersinn weitergedreht.

''Hinweis:'' 
Die Rotation bezieht sich '''nur''' auf den Framebuffer. Ein anschließend gestartetes Qtopia (z.B.) bleibt von der gewählten Einstellung unberührt.
In eigenen Anwendungen, welche eine grafische Oberfläche bereitstellen, lässt sich die Rotation allerdings verwenden, indem man einfach die Datei '''/proc/cmdline''' ausliest und den dort gegebenen Wert verwendet, um seine Bildschirmausrichtung anzupassen.

=== Bootloader ===
Die beiden verfügbaren Bootloader sind vivi (ein "standard-s3c24xx-Linux-Bootloader") und u-boot, '''der''' Bootloader für embedded-Systeme schlechthin ;)

Gemeinsam haben sie eigentlich nur, dass sie '''a)''' funktionieren und '''b)''' einen Linux-Kernel laden können. 
Der große Nachteil von vivi ist, dass es nur mit [http://en.wikipedia.org/wiki/YAFFS YAFFS2]-Dateisystemen umgehen kann, die auf dem onboard-Flash liegen müssen.
Sobald der Kernel geladen ist, ist das kein Problem mehr, doch der Kernel muss eben im Flash liegen. 
Um nun z. B. von USB-Festplatten/Sticks und SD-/MMC-Karten booten zu können, muss also u-boot installiert werden.

'''WARNUNG: An einem Bootloader herumzuspielen, kann sehr böse ausgehen, etwa mit dem unbootbar-mach-Vorgang, der durch zu wenig Nachdenken ausgelöst wird.
Das mini2440 lässt sich zwar jederzeit per JTAG mit LPT-Adapter zurückholen, ist doch aber eigentlich unnötig ;)'''

==== uboot ====

Der Bootloader uboot wurde von "buserror" soweit an das mini2440 angepasst, dass er mehr oder weniger läuft.
Für die verschiedenen Boards gelten also auch leicht verschiedene Anweisungen um uboot ins Wasser zu bekommen.

Das git und die Seite von "buserror" ist [http://code.google.com/p/mini2440/ hier] zu finden.

Boards:
* 64MB
* 128MB
* 256MB
** [[Datei:mini2440.h]]
** [[Datei:uboot.bin]]
* 1GB

Den u-boot-Fork von buserror laden wir am besten mit git. Weiterhin benötigen wir einen Cross-Compiler (Siehe oben). Die letzte mir bekannte Version des GCC mit dem sich das "U-Boot" kompilieren lässt ist 4.3.4. Folgende Einstellungen werden im Abschnitt verwendet:
<pre> Verzeichnis: /mnt/mini2440
CHOST/CROSS-COMPILE: arm-softfloat-linux-gnueabi
</pre>
Starten wir damit, den Quellcode zu laden:
<pre> $ cd /mnt/mini2440
$ git clone git://repo.or.cz/u-boot-openmoko/mini2440.git u-boot</pre>
Dann ab ins Source-Verzeichnis und mit den Defaults für das Mini2440 konfigurieren:
<pre> $ cd u-boot
$ CROSS_COMPILE=arm-softfloat-linux-gnueabi- make mini2440_config</pre>
Wenn man noch etwas manuell ändern möchte, dann die Datei include/configs/mini2440.h bearbeiten, z. B. für das Mini2440-256MB:
<pre> #define USE_920T_MMU 1
//#define CONFIG_USE_IRQ 1 /* Needed for USB device! */
</pre>
(CONFIG_USE_IRQ auskommentieren, damit das Mini2440 u-boot aus dem RAM ausgeführt werden kann. Leider kann man dann im "U-Boot" kein USB-Gerät mehr ansprechen, um ggfl. mal wieder aufzutauchen). 
Zusätzlich kann man noch defaults für das Environment (bootargs, ip, ...) festlegen.
 
Anschließend das "U-Boot" kompilieren:
<pre> $ CROSS_COMPILE=arm-softfloat-linux-gnueabi- make</pre>
 
Im Verzeichnis tools findet man mkimage. Damit kann man aus einem zImage (Linux-Kernel) ein uImage machen. Dieses uImage lässt sich von u-boot aus laden (Nand, NFS, TFtp, MMC) und ausführen.
<pre> mkimage -A arm -O linux -T kernel -C none -a 0x30008000 -e 0x30008000 -d path-to/zImage path-to/uImage</pre>
Jetzt haben wir ein von u-boot ausführbaren Linux-Kernel.

== Multimedia ==

=== Abspielen von Audio-Daten ===
Mit dem FriendlyARM-Image gibt es zwei Möglichkeiten Audio-Dateien abzuspielen. Die Eine ist, Qtopia zu starten und dort einfach die Datei von SD-Karte, USB, ... auszuwählen und er spielt sie ab.

Die andere ist, die Datei auf der Konsole mit ''madplay dateiname.mp3'' abzuspielen. [http://www.digipedia.pl/man/doc/view/madplay.1/ Hier] die Manpage zu madplay.

==== MPD - der Music Player Daemon ====
Mit einem eigenen Image oder wenn man sich alles von Hand compilieren will ist der [http://www.musicpd.org/ Music Player Daemon] ein genialer Musik-Player. Er lässt sich durch sehr sehr viele verschiedene Clients steuern und braucht dabei nahezu kaum Rechenleistung. 
Der eigentliche Player läuft vollkommen "versteckt" im Hintergrund. Um ihn zu steuern wird vom Client eine Verbindung aufgebaut und die entsprechenden Befehle gesendet. 
Die Clients müssen noch nicht einmal auf dem Board laufen, können auch auf jedem anderen Rechner im Netzwerk oder Internet sein. Man muss einfach nur die IP und den Port angeben.

Mit gerade mal etwa 100 Zeilen Code lässt sich eine einfach zu nutzende Client-Lib in C programmieren um dann seine eigenen Clients zu schreiben. Damit lässt sich der MPD durch so ziemlich jedes Ereignis an einem Rechner steuern.
[[MPD Client Programming|hier]] habe ich einen Artikel erstellt, der das wichtige dafür beschreibt.

=== Aufnehmen von Audio-Daten ===
=== Abspielen von Video-Daten ===

Ich selbst habe noch keinen Player, bis auf den vom originalen Image mit Qtopia gesehen/compiliert, welcher Filme einigermaßen flüssig abspielt.

Mein Ansatz momentan ist, den MPlayer mit fbdev, directfb und sdl mit Framebuffer Ausgabe direkt auf den Framebuffer schreiben zu lassen.
Allerdings habe ich damit bisher nur sehr sehr magere Ergebnisse gehabt.

=== Kamera-Interface ===

== Hardware ==
Nahezu alles ist über die verschiedenen Header auf dem Board zu erreichen
=== Pinouts ===
[[Bild:mini2440_pinout.jpg|450px]]
{| class="wikitable"
|+ '''Audio / UART'''
|-
! Pin || Audio IN || CON1, CON2, CON3 || CON8 || J1 (ext. NAND/NOR-sw)
|-
| 1 || IN || TX || VIN || NORBOOT
|-
| 2 || GND || RX || GND || OM0
|-
| 3 || IN || 5V || GND || NANDBOOT
|-
| 4 || || GND || VDD5V||
|}

{| class="wikitable"
|+ '''CON4 GPIO, CON5'''
|-
! Pin || CON5 || CON4 GPIO || CAMERA || CON12 || JTAG
|-
| 1 || 5V || 5V || SDA || EINT8/GPG0 || 3.3V
|-
| 2 || GND || 3.3V || SCL|| EINT11/GPG3 || 3.3V
|-
| 3 || EINT17|| GND || EINT20|| EINT13/GPG5 || /TRST
|-
| 4 || EINT18|| /RESET || CAMRST|| EINT14/GPG6 || /RESET
|-
| 5 || EINT3|| AIN0 || CAM_CLOCK|| EINT15/GPG7 || TDI
|-
| 6 || EINT9|| AIN1 || CAM_HREF|| EINT19/GPG11 || TDO
|-
| 7 || /GCS1|| AIN2 || CAM_VSYNC|| 3.3V || TMS
|-
| 8 || /GCS2 || AIN3 || CAM_PCLK|| GND || GND
|-
| 9 || /GCS3 || EINT0 || CAMDATA7|| ||TCK
|-
| 10 || /GCS5|| EINT1 || CAMDATA6|| ||GND
|-
| 11 || L/OE|| EINT2 || CAMDATA5
|-
| 12 || L/WE|| EINT3 || CAMDATA4
|-
| 13 || /WAIT|| EINT4 || CAMDATA3
|-
| 14|| /RESET|| EINT5 || CAMDATA2
|-
| 15 || /XDACK0|| EINT6 || CAMDATA1
|-
| 16 || /XDREQ0|| EINT8 || CAMDATA0
|-
| 17 || LADDR0|| EINT9 || 3.3V
|-
| 18 ||LADDR1|| EINT11 || VDDCAM
|-
| 19 ||LADDR2|| EINT13 || 1.8V
|-
| 20 ||LADDR3|| EINT14 || GND
|-
| 21||LADDR4|| EINT15 ||
|-
| 22||LADDR5|| EINT17 || ||
|-
| 23||LADDR6|| EINT18
|-
| 24||LADDR24|| EINT19
|-
| 25||LDATA0||MISO
|-
| 26||LDATA1||MOSI
|-
| 27||LDATA2||CLOCK
|-
| 28||LDATA3||SS
|-
| 29||LDATA4|| SCL
|-
| 30||LDATA5|| SDA
|-
| 31||LDATA6||GPB0
|-
| 32||LDATA7||GPB1
|-
|33 ||LDATA8||CLKOUT0
|-
| 34 ||LDATA9||CLKOUT1
|-
| 35||LDATA10
|-
|36 ||LDATA11
|-
| 37 ||LDATA12
|-
| 38 ||LDATA13
|-
| 39 ||LDATA14
|-
| 40 ||LDATA15

|}

=== Steckverbinder ===
Digi-Key:
{| class="wikitable"
! Connector || Hersteller || Artikelnummer || Teilenummer
|-
| CON1,2,3,8 || JST Sales America Inc || PHR-4 || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=455-1164-ND 455-1164-ND]
|-
| Audio IN, J1 || JST Sales America Inc || PHR-3 || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=455-1126-ND 455-1126-ND]
|-
| || JST Sales America Inc || SPH-002T-P0.5L || [http://search.digikey.com/scripts/DkSearch/dksus.dll?Detail&name=455-2148-1-ND 455-2148-1-ND]
|-
| CON4 || Sullins Connector Solutions || SFH213-PPPN-D17-ID-BK-M181 || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=S9061-ND S9061-ND]
|-
| || Sullins Connector Solutions || SBH21-NBPN-D17-ST-BK || [http://search.digikey.com/scripts/DkSearch/dksus.dll?keywords=S9023-ND S9023-ND]

|}

==== onboard Hardware ====
Sobald man mal anfangen möchte, sich mit der Hardware auseinanderzusetzen, sollte man natürlich auch wissen wie, was und wo dran.

''... an welchem EINT war ... Low oder High aktiv? ...''

[[Bild:mini2440_eeprom.jpg||300px]][[Bild:mini2440_buttons.jpg||300px]][[Bild:mini2440_leds.jpg||300px]][[Bild:mini2440_poti.jpg||300px]]
[[Bild:mini2440_buzzer.jpg||300px]]

=== [[UART]] ===
Die S3C2440 besitzt insgesamt drei unabhängige UARTs.

'''Die Spannungspegel der Rx und Tx Pins sind etwas verwirrend. Auf dem Stecker liegen 5V an, doch das Datenblatt sagt nicht, ob die Rx und Tx Pins auch 5V-Tolerant sind. Daher sollte man das ausschliessen. Ein Spannungsteiler aus 3k3 und 2k2 an der Rx-Leitung vom Prozessor sollte das Problem beheben, solange der Empfänger an der Tx-Leitung 3.3V noch als H-Signal versteht.'''

{| class="wikitable"
|+ '''UARTs'''
|-
! UART || 64 byte FIFO || IrDA 1.0 || RTS/CTS Leitungen|| Spannungspegel (L - H)
|-
| uart0 || * || * || * || 0V - 3,3V / RS232
|-
| uart1 || * || * || * || 0V - 3,3V
|-
| uart2 || * || * || x || 0V - 3,3V
|}

Über die Ansteuerung auf Hardwareebene braucht man sich, solange man ein Betriebssystem verwendet, '''keine''' Gedanken zu machen.
Unter Linux sind die drei UARTs über ttySAC0, ttySAC1 und ttySAC2 zu erreichen.

=== [[LED|LEDs]] ===
Wenn der Kerneltreiber für die LEDs mit eincompiliert wurde, ist es ein leichtes, die LEDs mit einer kleinen Hand voll C-Zeilen anzusprechen.

Man öffnet die Gerätedatei und mittels ''ioctl()'' schreibt man die Werte in die Gerätedatei.

Der Aufruf von ioctl sieht so aus:
<c>
ioctl(descriptor, AN/AUS, LED_NUMMER);
</c>
Also muss man um zum Beispiel LED0 anzuschalten für AN/AUS '''1''' angeben und für LED_NUMMER die '''0'''.
Dafür habe ich im Abschnitt C-Code zwei Beispiel-Funktionen geschrieben. Die erste erwartet AN/AUS und LED_NUMMER als Argument, die Zweite erwartet eine Bitmaske, was mir persönlich doch besser gefällt ;)

==== C-Code ====
<c>int setleds(int on, int led_no) {
int led_fd = open("/dev/leds0", 0);
if (led_fd < 0) { led_fd = open("/dev/leds", 0); }
if (led_fd < 0) { perror("open device leds"); return(-1); }

ioctl(led_fd, on, led_no);

close(led_fd);
return 0;
}

int setledmask(int mask) {
int led_fd = open("/dev/leds0", 0);
if (led_fd < 0) { led_fd = open("/dev/leds", 0); }
if (led_fd < 0) { perror("open device leds"); return(-1); }

if(mask & 0x01) ioctl(led_fd, 1, 0); else ioctl(led_fd, 0, 0);
if(mask & 0x02) ioctl(led_fd, 1, 1); else ioctl(led_fd, 0, 1);
if(mask & 0x04) ioctl(led_fd, 1, 2); else ioctl(led_fd, 0, 2);
if(mask & 0x08) ioctl(led_fd, 1, 3); else ioctl(led_fd, 0, 3);

close(led_fd);
return 0;
}
</c>

==== LED-sysfs ====
Bei aktiviertem sys-fs Kerneltreiber für LEDs, kann man diese im Verzeichnis '/sys/class/leds/' finden und ansteuern.
<pre>
cd /sys/class/leds/ # wechselt in den Ordner
ls -lsa # listet alle Vorhandenen LEDs auf
echo 1 > led4/brightness # LED AN
echo 0 > led4/brightness # LED AUS
# oder
echo 1 > /sys/class/leds/led4/brightness # LED AN
echo 0 > /sys/class/leds/led4/brightness # LED AUS
</pre>

=== [[I2C]] ===
==== i2ctools ====
Die [http://www.lm-sensors.org/wiki/I2CTools i2ctools] sind Linux-Userspace Programme, welche dafür gedacht sind, auf einfache Weise auf der Konsole mit I2C Geräten zu kommunizieren.
==== 24xx [[EEPROM]]s ====
==== [[Port-Expander]] ====
===== PCF8574 / PCF8574a =====
Einen [[PCF8574]] anzusteuern ist sehr einfach. Mit den i2ctools kann man damit erste Tests machen um zu sehen, ob er funktioniert.

Der Port-Expander wird mit den 3.3V versorgt, welche das Board liefert, SDA und SCL natürlich ebenfalls anschliessen.
Ich habe alle drei Adress-Pins auf '''L''' gelegt und erhalte von ''i2cdetect'' so die Adresse '''0x38'''.

=== [[SPI]] ===
=== [[PWM]] ===
==== onboard buzzer ====
=== [[ADC]] ===
==== Touchscreen ====
Wenn der Kernel-Treiber installiert ist, kann der Touchscreen wie z. B. jede Maus über das event-Interface angesprochen werden.
Normalerweise liegt der Touchscreen auf ''/dev/input/event0''.
Diese Gerätedatei muss man auch der tslib angeben.

==== LCD Backlight ====
Wenn der Kernel-Treiber installiert ist, kann die Hintergrundbeleuchtung des Displays einfach über die entsprechende Geräte-Datei ein- bzw. ausgeschaltet werden. 
einschalten: <pre># echo 1 > /dev/backlight</pre>
ausschalten: <pre># echo 0 > /dev/backlight</pre>

==== onboard Poti ====
Hierzu muss wieder der Kerneltreiber mit eincompiliert sein, damit man das Gerät ''/dev/adc'' hat. Im FriendlyARM-Kernel ist der Treiber fest mit drin.

Die Funktion getpoti() liest in einer Schleife mehrmals den Potiwert ein und bildet einen Mittelwert, der zurückgegeben wird.
Die Anzahl der Werte, aus denen der Mittelwert gebildet wird, wird mit dem #define ''LOOPs'' angegeben.
===== C-Code =====
<c>
#define LOOPS 12 // 12 Werte fuer Mittelwert

unsigned int getpoti() {
int value, i, fd = open("/dev/adc", 0);
unsigned int add = 0, ret;
if (fd < 0) { printf("cant open adc device!\n"); return -1; }

for(i = 0; i < LOOPS; i++) {
char buffer[30];
int len = read(fd, buffer, sizeof buffer -1);
if (len > 0) {
buffer[len] = '\0';
value = -1;
sscanf(buffer, "%d", &value);
add += value;
} else {
printf("cant read from adc device!\n");
close(fd);
return -1;
}
}
close(fd);
ret = add / LOOPS;
return ret;
}
</c>

=== GPIO ===
Da der S3C2440 über sage und schreibe '''130''' GPIOs verfügt, mit diversen Funktionen, wie I2C, PWM, ..., das setzen der "Drive Strength" (maximaler Strom an machen Pins), ... ist das Ganze nicht mehr so einfach wie bei einem AVR.
Der Bastler sollte hier schon genau wissen was er will vorallem das [[Media:S3C2440_datasheet_samsung.pdf|Datenblatt]] zu Rate ziehen.
Die Funktionen und Register des Chips sind ab Seite '''274''' (Kapitel ''IO-Ports'') zu finden.
Die elektrischen Daten sind ab Seite '''554''' zu finden.

==== C-Code für die onboard-Buttons ====
Hierfür wird wird der Kerneltreiber benötigt. Im FriendlyARM-Kernel ist dieser fest mit drin.

Wenn die Buttons eingelesen werden, erhält man für jeden nicht gerdrücken Buttons ''0x30'' und für jeden gedrückten Button ''0x31''.
Die Funktion liest die Buttons ein und vergleicht den Wert, sobald 0x31 kommt, ist sie beendet. Die Buttons sind von 0 bis 5 nummeriert.

<c>
int wait4button(int button) {
char btn[6] = {'0', '0', '0', '0', '0', '0'};
int fd = open("/dev/buttons", 0);
if (fd < 0) { printf("cant open buttons device"); return(-1); }

while(btn[button] == 0x30) { // if a button is released, we read 0x30, if pressed 0x31
if (read(fd, btn, sizeof btn) != sizeof btn) {
printf("cant read buttons!");
close(fd);
return(-1);
}
}
close(fd);
return 0;
}</c>

==== GPIO-sysfs ====
Bei aktiviertem sys-fs Kerneltreiber für GPIOs, kann man diese im Verzeichnis '/sys/class/gpio/' finden und ansteuern. Eine gute Erklärung ist dazu [http://www.avrfreaks.net/wiki/index.php/Documentation:Linux/GPIO#gpio-sysfs hier] zu finden.

=== Real Time Clock ===
Für die Real Time Clock, welche fest im Prozessor integriert ist, gibt es einen Kerneltreiber.

Lesen/Setzen lässt sich sich sehr einfach mit dem Tool [http://linux.die.net/man/8/hwclock hwclock].
=== Beispielprogramme ===

Hier habe ich ein paar kleine Beispielprogramme im Quellcode hochgeladen.

* [[Media:led_adc.c]] Herzschlag auf den LEDs, Geschwindigkeit mit Poti einstellen. Compilieren mit ''arm-linux-gcc led_adc.c -o led_adc''.

== Andere Betriebssysteme ==

=== uCos2 ===
=== Windows CE ===
=== FreeRTOS ===
=== emdedian ===

== Software mit Betriebssystem ==
* Grafische Oberfläche mit der SDL-Bibliothek erstellen: [[Mini2440 SDL GUI Programmierung]]

== Software ohne Betriebssystem ==

=== Entwicklungsumgebung ===
=== Beispiele ===

== Wo kaufen? ==

Zu beziehen ist das Board entweder über Ebay, meist aus China, oder bei [http://www.watterott.com/de/FriendlyARM Watterott].

== Eigene Displays an das Mini anschließen ==

* Displays mit LVDS Anschluss können z.B. mit diesem selbst gebauten Adapter an das Mini angeschlossen werden. http://www.mikrocontroller.net/topic/217774#new

== Links und Quellen ==
* [http://www.friendlyarm.net/products/mini2440 Übersicht auf der Friendlyarm Seite]
=== Howtos ===
* [http://wiki.linuxmce.org/index.php/Mini2440 Kernel, u-boot und qemu-mini2440 compilieren]
* [[Mini2440 SDL GUI Programmierung]]

=== Repositories ===

* [http://code.google.com/p/mini2440/downloads/list Emdebian+Angstrom Images, s3c_boot_usb]

* [http://programmers-projects.de/node/10 Programmer's-Projects Mini2440 Projekt (überarbeitetes USB-Upload-Tool für Linux und mehr)]

=== Youtube und ähnliche ===

[[Category:ARM-Boards]]
[[Category:Linux-Boards]]

Diskussion:AVR Bootloader FastBoot von Peter Dannegger

2010-12-21T12:24:38Z

Kruemeltee: Die Seite wurde neu angelegt: „Hi, ich hab mir ein kleines Script + Hand voll Zeilen C Code in die UART-RX-ISR gebastelt, welches mir per Makefile automatisch den Controller resettet um in den…“

Hi,

ich hab mir ein kleines Script + Hand voll Zeilen C Code in die UART-RX-ISR gebastelt, welches mir per Makefile automatisch den Controller resettet um in den Bootloader zu gelangen. Kann ich das hier in den Artikel mit reinpacken ?
--[[Benutzer:Kruemeltee|Kruemeltee]] 12:24, 21. Dez. 2010 (UTC)

Micro2440

2010-08-21T06:19:24Z

Kruemeltee: /* uBoot ENVs Beschreibung */

= Micro2440 =
--[[Benutzer:Theborg0815|Theborg0815]] 19:46, 3. Jul. 2010 (UTC)
[http://www.friendlyarm.net/products/micro2440 Micro2440 von FriendlyARM]

Das Micro2440 ist im Prinzip wie das [http://www.mikrocontroller.net/articles/Mini2440 Mini2440] nur dass es keine 64/128MB Flash Variante gibt.
Aufgebaut ist es als Stamp-Modul, welches meistens mit einem SDK-Board, der Peripherie und wahlweise einem 3,5" / 7" TFT oder einen LCD2VGA Adapter kombiniert wird.

=== Technische Daten (Stamp Modul) ===

[[Datei:Micro2440.jpg|350px|right]]

'''Dimension:''' 63 x 52 mm
'''CPU:''' 400 MHz Samsung S3C2440A ARM920T (Max freq. 533 MHz)
'''RAM:''' 64 MB SDRAM, 32 bit 100 MHz Bus
'''Flash:''' 64 MB / 128 MB / 256 MB / 1GB NAND Flash and 2 MB NOR Flash with BIOS
'''User Outputs:''' 4x LEDs Expansion headers (2.0mm)
'''Debug:''' 10 pin JTAG (2.0mm)
'''OS Support:''' Android, Linux 2.6, Windows CE 5 and 6

=== Technische Daten (SDK-Board) ===

[[Datei:Micro2440-SDK.jpg|350px|right]]

'''Dimension:''' 180 x 130 mm
'''EEPROM:''' 1024 Byte 24C08 (I2C)
'''Ext. Memory:''' SD-Card socket
'''Serial Ports:''' 3x DB9 connector (RS232)
'''USB:''' 4x USB-A Host, 1x USB-B Device
'''Audio Output:''' 3.5 mm stereo jack
'''Audio Input:''' 3.5mm jack (mono)
'''Ethernet:''' RJ-45 10/100M (DM9000)
'''RTC:''' Real Time Clock with battery
'''Beeper:''' PWM buzzer
'''Camera:''' 20 pin Camera interface
'''LCD:''' Connector for FriendlyARM Displays (3,5" and 7") and VGA Board
'''Touch Panel:''' 4 pin
'''User Inputs:''' 6x push buttons and 1x A/D pot
'''Expansion header''' (2.0mm)
'''Power:''' 5V connector, power switch and LED

= Software =
== U-Boot ==
==== U-Boot aus den Quellen bauen ====

Leider kann der vivi-Bootlader nicht viel. Vivi unterstützt nur yaffs2 Kernel Images, daher ist es sinnvoll diesen durch den U-Boot-Bootloader auszutauschen. Ich benutze U-Boot aus dem OPENMOKO Projekt für das Micro2440 mit 256MB.

Der compilierte U-Boot-Bootloader ist zu finden unter:[[Datei:uBoot-256MB.bin]].

Für den Anfang sollte abgewogen werden, ob der vivi-Bootloader reicht. Im Fehlerfall kann dieser per JTAG wieder eingespielt werden.

Voraussetzungen dafür ist ein Cross-Compiler z.B. der von [http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 Codesourcery].

Im ersten Schritt muss das Build-Verzeichnis angelegt werden und das git-Repository heruntergeladen werden.. Das geschieht mit den Befehlen:
<c>
mkdir uboot ; cd uboot
git clone git://repo.or.cz/u-boot-openmoko/mini2440.git
</c>
Danach müssen die Source-Dateien für das micro2440 eingestellt und compiliert werden:
<c>
cd mini2440
export CROSS_COMPILE=arm-none-linux-gnueabi-
make mini2440_config
make all
</c>

==== U-Boot Flash’en ====

Den Bootswitch S2 auf NOR stellen, sobald vivi erscheint "q" (in der vivi Konsole) drücken.

Damit U-Boot ab der Adresse 0x32000000 programmiert wird, muss der folgende Befehl eingeben werden:
<c>
load ram 0x32000000 <uboot bin file grösse in bytes> u-boot
</c>
Nun wartet Vivi auf die Datei. In der Shell wird das hochladen mit dem folgenden Befehl initiiert. Die Dateiübertragung erfolgt über USB.
<c>
sudo s3c2410_boot_usb u-boot.bin
</c>
Als nächstes soll das U-Boot gestartet werden. Dazu muss an die Speicherstelle gesprungen werden, an der das U-Boot programmiert wurde. Dies wird mit dem folgendem Befehl erreicht:
<c>
go 0x32000000
</c>
Waren alle vorherigen Schritte erfolgreich, sollte nun die U-Boot Konsole angezeigt werden.(MINI2440#). Anschließend wird nun der NAND-Flash vorbereitet

Zuerst muss das NAND-Flash gelöscht werden, dies wird mit dem folgendem Befehl erreicht:
<c>
nand scrub
</c>
Danach wird die Bad-Block Tabelle erstellt, dies kann etwas Zeit in Anspruch nehmen:
<c>
nand createbbt
</c>
Damit U-Boot in das Flash geschrieben wird, muss folgender Befehl ausgeführt werden.
<c>
nand write.e 0x32000000 0x0 <uBoot bin grösse in hex>
</c>
Für das Partitionieren des Flashs dient der Befehl:
<c>
dynpart
</c>
Environment Speicher einrichten:
<c>
dynenv set u-boot_env
</c>
Enviroment Parameter sichern:
<c>
saveenv
</c>
Nachdem alle Schritte durchgeführt wurden, muss nur noch das Bord ausgeschaltet werden und S2 wieder auf NAND gestellt werden. Nach dem Einschalten sollte euch nun das U-Boot begrüßen.

== Kernel/Filesystem ==
=== Kernel aus den Quellen compilieren ===
Jetzt steht man vor der Wahl welchen Kernel man nimmt. Egal ob EMDebian, Gentoo oder Android, man braucht ihn so oder so. Die fertigen Kernel von [http://www.friendlyarm.net/downloads FriendlyARM] können nur VFAT und JFFS2 daher eignen sich diese nur bedingt für ein System z.b. auf SD/USBStick oder Ext. Platte. Daher ist es sinnvoll sich selbst einen Kernel zu bauen, was nicht schwer ist.

Als erstes besorgen wir uns die Kernel-Quellen und entpacken sie:

==== Gentoo/emDebian ====
<c>
mkdir micro2440
cd micro2440
git clone git://repo.or.cz/linux-2.6/mini2440.git linux-2.6.32-rc8
</c>

==== Android ====
<c>
mkdir android
cd android
git clone git://gitorious.org/android-mini2440/kernel-opencsbc.git
</c>

Als nächstes laden wir die Default Config und erstellen die .Config für das Micro2440:
<c>
cd linux-2.6.32-rc8
CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make mini2440_defconfig
</c>

Wenn man noch etwas ändern möchte (z.b. ext3-Treiber) startet man "menuconfig":
<c>
CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make menuconfig
</c>
Den Kernel anschließend compilieren:
<c>
CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make
</c>
Später kann man noch die Module auf die SD-Karte kopieren:
<c>
CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm INSTALL_MOD_PATH=/mnt make modules_install
</c>
Als letztes muss das Kernel Image für U-Boot vorbereitet werden. Aus dem zImage (gzip komprimiertes Kernel-Image) wird ein uImage für U-Boot so erstellt:
<c>
cd .../arch/arm/boot
mkimage -A arm -O linux -T kernel -C none -a 0x30008000 -e 0x30008000 -d zImage uImage
</c>

=== Filesystem erstellen ===
Als erstes brauchen wir ein RootFS dieses brauchen wir um später die Partition damit zu füllen.

==== emDebian ====
<c>
mkdir armel-rootfs
debootstrap --verbose --arch armel --foreign lenny armel-rootfs http://ftp.de.debian.org/debian
cd armel-rootfs
tar cfjv ../armel-rootfs.tar.bz2 *
</c>

==== Gentoo ====
http://distfiles.gentoo.org/releases/arm/autobuilds/current-stage3/armv4tl-softfloat-linux-gnueabi/

==== Android ====
<c>
mkdir android
cd android
git clone git://gitorious.org/android-mini2440/android-mini2440.git
cd android-mini2440
tar cfjv ../android-rootfs.tar.bz2 *
</c>

== Speichermedien vorbereiten ==
=== SD-Karte und USB Medien ===
Als nächstes bereiten wir ein Speichermedium vor, wir brauchen 3 Partitionen, 2x EXT2 und einmal Swap das Beispiel gilt für eine 2GB SD-Karte.

Das machen wir am besten mit fdisk in der Konsole, man kann auch gparted(Grafisch) nutzen aber komischerweise mountet dann bei mir das RootFS nicht ebenso wenn das RootFS ext3 ist, so wie ich raus gefunden habe geht das nur mit SDHC Karten also SD-Karten mit Speicher der >2GB ist.
<c>
fdisk /dev/<Bezeichnung der SD-Karte>
</c>
Der Rest ist recht einfach, einfach folgendes eingeben: dp1 np1 <enter> +20MB <enter> np2 +1800MB <enter> np3 <enter> <enter>

Danach mit p schauen ob alle 3 Partitionen erstellt wurden und mit w Speichern und fdisk beenden.

Jetzt müssen wir noch die Partitionen Formatieren(für ext3 muss noch -j in der zweiten Zeile angegeben werden):
<c>
mke2fs /dev/<Bezeichnung der SD-Karte>1
mke2fs /dev/<Bezeichnung der SD-Karte>2
mkswap /dev/<Bezeichnung der SD-Karte>3
</c>

=== BootFS/RootFS einrichten ===

Dieses ist bei allen Distributionen gleich als erstes kopieren wir den Kernel auf das Speichermedium.
<c>
mount /dev/<Bezeichnung der SD-Karte>1 /mnt
cp ../linux-2.6.32-rc8/arch/arm/boot/uImage /mnt
sync
umount /dev/<Bezeichnung der SD-Karte>1
</c>
Jetzt muss noch das RootFS erstellt werden:
<c>
mount /dev/<Bezeichnung der SD-Karte>2 /mnt
tar xvzfop /path/to/downloaded/<RootFSfile> -C /mnt
sync
umount /dev/<Bezeichnung der SD-Karte>2
</c>

== uBoot ENVs einrichten ==
So jetzt sind wir fast fertig nur das Wichtigste fehlt noch, wir müssen dem Bootlader noch sagen wo er den Kernel findet und dem Kernel wo er das RootFS findet.

Dazu drücken wir eine Taste um denn Autoboot zu unterbrechen und stellen folgendes ein:
<c>
setenv bootcmd mmcinit ; ext2load mmc 0:1 0x31000000 uImage ; bootm 0x31000000
setenv bootargs noinitrd mini2440=1tb rootfstype=ext2 root=/dev/mmcblk0p2 rw rootwait
saveenv
</c>

Bei Android muss noch ein "init=linuxrc" in die zweite Zeile eingefügt werden.

So das war es wen ihr alles durchgearbeitet habt könnt ihr die SD-Karte in den Slot stecken und denn Reset drücken danach sollte das Bord booten.

== uBoot ENVs Beschreibung ==

{| class="wikitable"
|-
! ENV || BOOT Parameter || Beschreibung
|-
| bootargs || noinitrd ||
|-
| bootargs || mini2440=<0..9><t> || Type des Displays
|-
| || || 0 = 3,5" Display N35
|-
| || || 1 = 7" Display
|-
| || || 2 = VGA-Board
|-
| || || 3 = 3,5" Display T35
|-
| || || 4 = 5,6" Display Innolux
|-
| || || t = Touchscreen
|-
| || || b = Backlight
|-
| bootargs || rootfstype=<var> || Dateisystem mit RootFS
|-
| bootargs || root=<var> || Bezeichnung/Drive des RootFS (z.b. /dev/sda1)
|-
| bootargs || rw || Mount Parameter rw = Read/Write, ro = Readonly
|-
| bootargs || rootwait || Warte aufs Dateisystem bevor der Startvorgang fortgesetzt wird
|-
| bootargs || init=<var> || Startet das angegebene Programm nach dem der Kernelstart abgeschlossen ist.
|-
|}

== Tips/Tricks/Files ==
=== emDebian/Gentoo ===

==== Firstboot (Root Password)====

Beim ersten Start ist kein RootPW gesetzt b.z.w. es ist nicht bekannt, daher beim starten einfach init=/bin/bash in die Bootzeile von UBoot einfügen, danach kann mit passwd das Passwort gesetzt werden danach einfach das wieder entfernen und man kann sich normal einloggen.

==== /etc/fstab ====
Beispiel der /etc/fstab: [[Datei:fstab.txt]]

==== /etc/X11/xorg.conf ====
Beispiel xorg.conf fürs 7" Display: [[Datei:xorg.conf.txt]]

==== Touchscreen kalibrieren ====

Folgende Zeile zur /etc/X11/xorg.conf bei [Section "InputDevice"]
hinzufügen.
<c>
Option "Calibrate" "1"
</c>
Und dann noch folgendes machen:
<c>
apt-get install xserver-xorg-input-evtouch
cp /usr/share/xf86-input-evtouch/empty_cursor.xbm /
cd /usr/lib/xf86-input-evtouch
sh calibrate.sh
</c>

Mit folgenden Einträgen in die /etc/X11/xorg.conf bei [Section "InputDevice"] kann man jetzt erst mal die kreuze ausrichten (Siehe Bild.)

[[Datei:touch.jpg|300px|right]]

<c>
Option "x0" "0"
Option "y0" "0"
Option "x1" "0"
Option "y1" "0"
Option "x2" "0"
Option "y2" "0"
Option "x3" "0"
Option "y3" "0"
Option "x4" "0"
Option "y4" "0"
Option "x5" "0"
Option "y5" "0"
Option "x6" "0"
Option "y6" "0"
Option "x7" "0"
Option "y7" "0"
Option "x8" "0"
Option "y8" "0"
</c>
Als nächstes muss man noch die Min/Max werte ermitteln dazu Links unten und oben rechts die Min/Max werte in die xorg.conf übertragen.
<c>
Option "MinX" "153"
Option "MinY" "78"
Option "MaxX" "873"
Option "MaxY" "937"
</c>
Beim 7" Display muss man jetzt nur noch der SW sagen das der Touchscreen Falschrum verbaut ist dieses geht mit folgenden Eintrag in die xorg.conf.
<c>
Option "SwapY" "2"
Option "SwapX" "2"
</c>
Jetzt noch den Eintrag [Option "Calibrate" "1"] wieder aus der xorg.conf raus schmeißen dann sollte alles funktionieren.

==== Konsole auf dem TFT und Seriell ausgeben ====
<c>
echo ttySAC0 >> /etc/securetty
printf "T0:123:respawn:/sbin/getty 115200 ttySAC0\n" >> /etc/inittab
</c>

==== Virtuelle Maus ====

Wer lieber mit einer Maus arbeitet und ein iPOD/iPhone besitzt kann RemotePad benutzen einfach aus dem Appstore Laden (Kostenlos), den Quellcode für die Anwendung gibt es unter http://www.tenjin.org/RemotePad/ dieser lässt sich recht einfach auf dem Board oder in einem Buildroot compilieren.

==== Bildschirmtastatur ====

Als Bildschirmtastatur kann man xvkbd verwenden, bei Xfce z.b. einfach einen Link dazu in dem Autostart Ordner erstellen damit es beim Start von xfce geladen wird.

<c>
apt-get install xvkbd
ln /usr/bin/xvkbd - s ~/.config/autostart
</c>

=== Android ===
=== Sonstiges ===
==== SD-Karte/USB-LW Backupen/Restore ====
===== Backup =====
<c>
dd if=/dev/<Geräte Bezeichung> of=sd2gb.img
</c>

===== Restore =====
<c>
dd if=sd2gb.img of=/dev/<Geräte Bezeichung>
</c>

===== Restore 2GB Backup -> 4/8/16...GB SD-Karte =====
<c>
dd if=sd2gb.img of=/dev/<Geräte Bezeichung>
</c>
Und danach mit gparted die swap Partition Löschen danach die RootFS Partition vergrößern und eine neue swap erstellen.

= Hardware =
[[Datei:microsdkbesch.png|450px|right]]
== Connector / GPIO Belegung ==
=== SDK-Board ===
==== RS232/TTL(CON1-3) ====

{| class="wikitable"
|-
! PIN || CON1 || CON2 || CON3 || RS232(1) || RS232(2) || RS232(3)
|-
| 1 || TXD0 || TXD1 || TXD2 || || ||
|-
| 2 || RXD0 || RXD1 || RXD2 || RSTXD0 || RSTXD1 || RSTXD2
|-
| 3 || VDD5V || VDD5V || VDD5V || RSRXD0 || RSRXD1 || RSRXD2
|-
| 4 || GND || GND || GND || || ||
|-
| 5 || || || || GND || GND || GND
|-
| 7 || || || || RSCTS0 || ||
|-
| 8 || || || || RSRTS0 || ||
|}
Achtung !!! CON1-3 sind wohl nur zum Messen gedacht will man diese direkt benutzen muss der jeweilige MAX2323CPE ausgelötet werden.

==== CON8/Taster ====

{| class="wikitable"
|-
! PIN || CON8 || Taster || GPIO
|-
| 1 || EINT8 || K1 || GPG0/?
|-
| 2 || EINT11 || K2 || GPG3/nSS1
|-
| 3 || EINT13 || K3 || GPG5/SPIMISO1
|-
| 4 || EINT14 || K4 || GPG6/SPIMOSI1
|-
| 5 || EINT15 || K5 || GPG7/SPICLK1
|-
| 6 || EINT19 || K6 || GPG11/TCLK1
|-
| 7 || VDD33V || || 3,3V
|-
| 8 || GND || || GND
|}

==== CON6 ====

{| class="wikitable"
|-
! PIN || CON6 || GPIO ||PIN || CON6 || GPIO
|-
| 1 || VDD5V || 5V || 2 || VDD33V || 3,3V
|-
| 3 || GND || GND || 4 || nRESET || Reset
|-
| 5 || AIN0 || AD0 || 6 || AIN1 || AD1
|-
| 7 || AIN2 || AD2 || 8 || ? || ?
|-
| 9 || EINT0 || GPF0 || 10 || EINT1 || GPF1
|-
| 11 || EINT2 || GPF2 || 12 || EINT3 || GPF3
|-
| 13 || EINT4 || GPF4 || 14 || EINT5 || GPF5
|-
| 15 || EINT6 || GPF6 || 16 || EINT8 || GPG0
|-
| 17 || EINT17 || GPG7/nRST1 || 18 || EINT18 || GPE10/nCTS1
|-
| 19 || I2CSCL || I2CSCL/GPE14 || 20 || I2CSDA || I2CSDA/GPE15
|}

==== CON4/CMOS Camera ====

{| class="wikitable"
|-
! PIN || CON4 || GPIO || PIN || CON4 || GPIO
|-
| 1 || I2CSDA || GPE15 || 2 || I2CSCL || GPE14
|-
| 3 || EINT20 || GPG12 || 4 || CAMRST || GPJ12
|-
| 5 || CAMCLK || GPJ11 || 6 || CAM_HRES || GPJ10
|-
| 7 || CAM_VSYNC || GPJ9 || 8 || CAM_PCLK || GPJ8
|-
| 9 || CAMDATA7 || GPJ7 || 10 || CAMDATA6 || GPJ6
|-
| 11 || CAMDATA5 || GPJ5 || 12 || CAMDATA4 || GPJ4
|-
| 13 || CAMDATA3 || GPJ3 || 14 || CAMDATA2 || GPJ2
|-
| 15 || CAMDATA1 || GPJ1 || 16 || CAMDATA0 || GPJ0
|-
| 17 || VDD33V || 3,3V || 18 || VDD_CAM || VDD_CAM
|-
| 19 || VDD18V || 1,8V || 20 || GND || GND
|}

==== CON9/10 Touchscreen ====

{| class="wikitable"
|-
! PIN || CON9 || CON10 || GPIO
|-
| 1 || TSXM || TSXM || ?
|-
| 2 || TSYM || TSYM || ?
|-
| 3 || TSXP || TSXP || ?
|-
| 4 || TSYP || TSYP || ?
|}

==== CON5 ====

{| class="wikitable"
|-
! PIN || CON5 || GPIO || PIN || CON5 || GPIO
|-
| 1 || EINT17 || GPG9/nRST1 || 2 || EINT18 || nCTS1
|-
| 3 || nGCS1 || || 4 || EINT8 || GPG0
|-
| 5 || nGSC2 || || 6 || LnWBE1 ||
|-
| 7 || nGSC3 || || 8 || LnWE ||
|-
| 9 || LnOE || || 10 || nRESET ||
|-
| 11 || nWAIT || || 12 || nXDACK0 ||
|-
| 13 || LADDR0 || || 14 || nXDRWQ0 ||
|-
| 15 || LADDR1 || || 16 || LADDR2 ||
|-
| 17 || LADDR3 || || 18 || LADDR4 ||
|-
| 19 || LADDR5 || || 20 || LADDR6 ||
|-
| 21 || LADDR7 || || 22 || LADDR8 ||
|-
| 23 || LADDR9 || || 24 || LADDR10 ||
|-
| 25 || LADDR11 || || 26 || LADDR12 ||
|-
| 27 || LADDR13 || || 28 || LADDR14 ||
|-
| 29 || LADDR15 || || 30 || LADDR16 ||
|-
| 31 || LADDR17 || || 32 || LADDR18 ||
|-
| 33 || LADDR19 || || 34 || LADDR20 ||
|-
| 35 || LADDR21 || || 36 || LADDR22 ||
|-
| 37 || LADDR23 || || 38 || LADDR24 ||
|-
| 39 || LDATA0 || || 40 || DATA1 ||
|-
| 41 || LDATA2 || || 42 || DATA3 ||
|-
| 43 || LDATA4 || || 44 || DATA5 ||
|-
| 45 || LDATA6 || || 46 || DATA7 ||
|-
| 47 || LDATA8 || || 48 || DATA9 ||
|-
| 49 || LDATA10 || || 50 || DATA11 ||
|-
| 51 || LDATA12 || || 52 || DATA13 ||
|-
| 53 || LDATA14 || || 54 || DATA15 ||
|-
| 55 || VDD5V || 5V || 56 || GND || GND
|}

==== LCD0/LCD1 ====
{| class="wikitable"
|-
! PIN || LCD1 || LCD0 || PIN || LCD1 || LCD0
|-
| 1 || VDD5V || VDDLED5V || 2 || VDD5V || VDDLED5V
|-
| 3 || VD0 || ADJ || 4 || VD1 || GND
|-
| 5 || VD2 || GND || 6 || VD3 || VDD33V
|-
| 7 || VD4 || VDD33V || 8 || VD5 || MODE(DE/HV)
|-
| 9 || VD6 || VM/DE || 10 || VD7 || VFRAME
|-
| 11 || GND || VLINE || 12 || VD8 || GND
|-
| 13 || VD9 || VD7/B5 || 14 || VD10 || VD6/BD
|-
| 15 || VD11 || VD5/B3 || 16 || VD12 || GND
|-
| 17 || VD13 || VD4/B2 || 18 || VD14 || VD3/B1
|-
| 19 || VD15 || VD2/B0 || 20 || GND || GND
|-
| 21 || VD16 || VD15/G5 || 22 || VD17 || VD14/G4
|-
| 23 || VD18 || VD13/G3 || 24 || VD19 || GND
|-
| 25 || VD20 || VD12/G2 || 26 || VD21 || VD11/G1
|-
| 27 || VD22 || VD10/G0 || 28 || VD23 || GND
|-
| 29 || GND || VD23/R5 || 30 || LCD_PWR|| VD22/R4
|-
| 31 || GPB1 || VD21/R3 || 32 || nRESET || GND
|-
| 33 || VM || VD20/R2 || 34 || VFRAME || VD19/R1
|-
| 35 || VLINE || VD18/R0 || 36 || VCLK || GND
|-
| 37 || TSXM || VCLK || 38 || TSXP || GND
|-
| 39 || TSYM || L/R || 40 || TSYP || U/D
|-
| 41 || ? || || || ||
|}

=== Stamp-Modul ===

[[Datei:microstampbesch.png|450px|right]]

==== JTAG ====

{| class="wikitable"
|-
! PIN || GPIO || PIN || GPIO
|-
| 1 || VDD33V || 2 || VDD33V
|-
| 3 || nTRST || 4 || nRESET
|-
| 5 || TDI || 6 || TDO
|-
| 7 || TMS || 8 || GND
|-
| 9 || TCK || 10 || GND
|}

==== PA.1 / PB.1 / PC.1 ====

{| class="wikitable"
! || PA.1 || || PB.1 || || PC.1 ||
|-
! PIN || CON || GPIO || CON || GPIO || CON || GPIO
|-
| 1 || VDD5V || 5,0V || TSYM || ? || EINT7 || GPF7
|-
| 2 || GND || GND || TSYP || ? || EINT9 || GPG1
|-
| 3 || EINT19 || GPG11 || TSXM || ? || LnGCS1 ||
|-
| 4 || EINT18 || GPG10/nCTS1 || TSYM || ? || LnGCS3 ||
|-
| 5 || EINT17 || GPG9/nRST1 || VD22 || GPD14 || LnGCS2 ||
|-
| 6 || EINT16 || GPG8 || VD23 || GPD15 || LnWBE1 ||
|-
| 7 || EINT15 || GPG7/SPICLK1 || VD20 || GPD12 || LnGCS4 ||
|-
| 8 || EINT14 || GPG6/SPIMOSI1|| VD21 || GPD13 || LnWE ||
|-
| 9 || EINT13 || GPG5/SPIMISO1|| VD18 || GPD10 || LnOE ||
|-
| 10 || EINT11 || GPG3/nSS1 || VD19 || GPD11 || nRESET ||
|-
| 11 || EINT8 || GPG0 || VD16 || GPD8 || nWAIT ||
|-
| 12 || EINT6 || GPF6 || VD17 || GPD9 || nXDACK0 ||
|-
| 13 || EINT5 || GPF5 || VD14 || GPD6 || LADDR0 ||
|-
| 14 || EINT4 || GPF4 || VD15 || GPD7 || nXDREQ0 ||
|-
| 15 || EINT3 || GPF3 || VD12 || GPD4 || LADDR1 ||
|-
| 16 || EINT2 || GPF2 || VD13 || GPD5 || LADDR2 ||
|-
| 17 || EINT1 || GPF1 || VD10 || GPD2 || LADDR3 ||
|-
| 18 || EINT0 || GPF0 || VD11 || GPD3 || LADDR4 ||
|-
| 19 || WP_SD || GPH8 || VD8 || GPD0 || LADDR5 ||
|-
| 20 || SDCLK || GPE5 || VD9 || GPD1 || LADDR6 ||
|-
| 21 || SDCMD || GPE6 || VD6 || GPC14 || LADDR7 ||
|-
| 22 || SDDATA2 || GPE9 || VD7 || GPC15 || LADDR8 ||
|-
| 23 || SDDATA3 || GPE10 || VD4 || GPC12 || LADDR9 ||
|-
| 24 || SDDATA0 || GPE7 || VD5 || GPC13 || LADDR10 ||
|-
| 25 || SDDATA1 || GPE8 || VD2 || GPC10 || LADDR11 ||
|-
| 26 || LCDVF2 || OM0 || VD3 || GPC11 || LADDR12 ||
|-
| 27 || LCDVF0 || GPC5 || VD0 || GPC8 || LADDR13 ||
|-
| 28 || M_nRESET|| ? || VD1 || GPC9 || LADDR14 ||
|-
| 29 || DN1 || DN1/PDN0 || LCD_PWR || GPG4 || LADDR15 ||
|-
| 30 || DP1 || DP1/PDP0 || VM || GPC4 || LADDR16 ||
|-
| 31 || DN0 || DN0 || VFRAME || GPC3 || LADDR17 ||
|-
| 32 || DP0 || DP0 || VLINE || GPC2 || LADDR18 ||
|-
| 33 || AIN2 || AIN2 || VCLK || GPC1 || LADDR19 ||
|-
| 34 || VDDRTC || 1,8V || LEND || GPC0 || LADDR20 ||
|-
| 35 || AIN0 || AIN0 || CAMDATA7 || GPJ7 || LADDR21 ||
|-
| 36 || AIN1 || AIN1 || CAMDATA6 || GPJ6 || LADDR22 ||
|-
| 37 || L3MODE || GPB2 || CAMDATA5 || GPJ5 || LADDR23 ||
|-
| 38 || L3DATA || GPB3 || CAMDATA4 || GPJ4 || LADDR24 ||
|-
| 39 || L3CLOCK || GPB4 || CAMDATA3 || GPJ3 || LDATA0 ||
|-
| 40 || I2SLRCK || GPE0 || CAMDATA2 || GPJ2 || LDATA1 ||
|-
| 41 || I2SSCLK || GPE1 || CAMDATA1 || GPJ1 || LDATA2 ||
|-
| 42 || CDCLK || GPE2 || CAMDATA0 || GPJ0 || LDATA3 ||
|-
| 43 || I2SSDI || GPE3 || CAMCLK || GPJ11 || LDATA4 ||
|-
| 44 || I2SSDO || GPE4 || CAM_PCLK || GPJ8 || LDATA5 ||
|-
| 45 || GPB0 || GPB0 || CAM_VSYNC || GPJ9 || LDATA6 ||
|-
| 46 || GPB1 || GPB1 || CAM_HREF || GPJ10 || LDATA7 ||
|-
| 47 || TXD2 || GPH6 || EINT20 || GPG12 || LDATA8 ||
|-
| 48 || RXD2 || GPH7 || CAMRST || GPJ12 || LDATA9 ||
|-
| 49 || TXD1 || GPH4 || VDD5V || 5,0V || LDATA10 ||
|-
| 50 || RXD1 || GPH5 || GND || GND || LDATA11 ||
|-
| 51 || TXD0 || GPH2 || || || LDATA12 ||
|-
| 52 || RXD0 || GPH3 || || || LDATA13 ||
|-
| 53 || nCTS0 || GPH0 || || || LDATA14 ||
|-
| 54 || nRTS0 || GPH1 || || || LDATA15 ||
|-
| 55 || I2CSDA || GPE15 || || || VDD5V ||
|-
| 56 || I2CSCL || GPE14 || || || GND ||
|}

== Peripherie Beschaltung ==

=== SDK-Bord ===

<gallery caption="Gallery" widths="150px" heights="150px" perrow="3">
Datei:micro2440_ub.png| User Buttons
Datei:micro2440_ad.png|AD
Datei:micro2440_spk.png|Speaker
Datei:micro2440_ttl.png|TTL (con1-3)
Datei:micro2440_eeprom.png|EEPROM
Datei:micro2440_con6.png|GPIOs CON6
</gallery>

=== Stamp-Modul ===

<gallery caption="Gallery" widths="150px" heights="150px" perrow="4">
Datei:micro2440_jtag.png|JTAG
</gallery>

= Links/Downloads =

== Software ==
[http://code.google.com/p/mini2440/downloads/detail?name=s3c2410_boot_usb-20060807.tar.bz2&can=2&q= s3c2410 USB DL Tool für Linux]
[http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 Crosscompiler von CodeSourcery]

== Hardware ==
[http://www.electronics.diycinema.co.uk/ Einige Basteleien (Tempsensor, RGB Treiber, MEMS ...]
[http://www.sereno-online.com/site/ Programm Beispiele für WinCE und QT]

== Datenblätter ==
[http://www.friendlyarm.net/dl.php?file=micro2440_manual_20100204.pdf Anleitung(Chinesisch)]
[http://www.friendlyarm.net/dl.php?file=micro2440_dimension.pdf Dimension Stamp-Modul]
[http://www.friendlyarm.net/dl.php?file=micro2440_schematic.zip Micro2440 + SDK-Schaltplan]
[http://www.friendlyarm.net/dl.php?file=lcd70_schematic.zip 7" LCD Schaltplan]
[http://www.friendlyarm.net/dl.php?file=lcd35_schematic.zip 3,5" LCD Schaltplan]

== Händler ==
[http://www.watterott.com/de/FriendlyARM Bezugsquelle Watterott]

[[Category:ARM-Boards]][[Category:ARM]][[Category:Linux]]

Mini2440 SDL GUI Programmierung

2010-08-08T08:31:47Z

Kruemeltee:

Wer ein kleines Linuxboard mit Display hat, möchte sicher nicht nur die Kernelausgaben auf der Framebuffer-Konsole ansehen oder sich für die popligsten Anwendungen einen X-Server+Window Manager installieren, sich eine Anwendung schreiben und dann erst loslegen können.

Viel einfacher geht es in einigen Fällen mit [http://www.libsdl.org SDL]. Dieser Artikel beschreibt die Einrichtung einer Cross-Toolchain mit SDL-Support für das [[Mini2440]].
Die unterschiede von Board zu Board sind meist sehr gering, was die Display-Ausgabe angeht. Daher lässt sich dieser Artikel auch für einige andere Boards verwenden.

Hier ein Screenshot von einem meiner SDL-Programme: 
[[Bild:mini2440_sdl_menu_screenshot.png|100px]]

Die Vorraussetzungen hierfür sind:
* Die [http://www.mikrocontroller.net/articles/Mini2440#Toolchain FriendlyARM Toolchain]
* Funktionierender Framebuffer mit Framebuffer Konsole
* Ein wenig Zeit

= Einrichten der Cross-Toolchain =
Ich gehe davon aus, dass man alle kommenden Schritte als "normaler" User erledigt. Sämtliche Schritte, die als "root" erledigt werden müssen, wird ein "sudo" vorangestellt. Wenn das bei dir anders gehen sollte (z.B. su -c '...'), dann ändere es für dich!

== libsdl ==
<pre>
cd ~
wget http://www.libsdl.org/release/SDL-1.2.14.tar.gz
tar xvfz SDL-1.2.14.tar.gz
cd SDL-1.2.14
RANLIB=/usr/local/arm/4.3.2/bin/arm-linux-ranlib CROSS_COMPILE=arm-linux- ./configure --host=arm-linux --prefix=/usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/ \
--enable-input-tslib --enable-video-fbcon --disable-audio --disable-video-x11 --disable-video-directfb
time make
sudo time make install
</pre>
Diese Schritte dauerten bei mir ca 5 Minuten.

Nun lassen sich schon die ersten Programme mittels SDL compilieren. Allerdings fehlen noch zusätzliche libs, wie z.B. [http://www.ferzkopp.net/joomla/content/view/19/14/ sdl_gfx] und [http://www.libsdl.org/projects/SDL_image/ sdl_image] um Grafiken, Texte und Bilder anzeigen zu können. SDL alleine steht da ein wenig auf dem Schlauch.

Einen Haken hat die Sache noch. Dadurch, dass SDL in seinem Audio-Code auch Assembler verwendet habe ich es noch nicht hinbekommen, SDL mit ALSA oder OSS Support zu compilieren.
Wer dazu einen Tip hat, immer her damit :)

== libsdl_image ==
Mit dieser lib lassen sich recht einfach Bilder laden und anzeigen.
<pre>
cd ~
wget http://www.libsdl.org/projects/SDL_image/release/SDL_image-1.2.10.tar.gz
tar xvfz SDL_image-1.2.10.tar.gz
cd SDL_image-1.2.10
RANLIB=/usr/local/arm/4.3.2/bin/arm-linux-ranlib CROSS_COMPILE=arm-linux- ./configure --host=arm-linux --prefix=/usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/ \
--enable-gif --enable-jpg --enable-bmp
***HACK*** (siehe Text unter diesem Kasten)
sudo ln -s /usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/armv4t/usr/lib/libts.la /usr/local/lib/libts.la
sudo ln -s /usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/armv4t/usr/lib/libts.so /usr/local/lib/libts.so
***/HACK***
time make
sudo time make install
</pre>
Anmerkungen zum "Hack". Beim compilieren spuckt mir SDL_image einen Fehler aus. Es sagt mir, dass er in /usr/local/lib/ die tslib nicht finden kann. Dort hat er aber nichts zu suchen, da dies kein Pfad zum Cross-Compiling ist. Wie ich das abstelle, habe ich noch nicht herausgefunden, also habe ich einfach einen symbolischen Link angelegt.

== libsdl_gfx ==
Diese lib stellt einen Haufen Grafikfuntkionen bereit, wie Polygone, Rechtecke, Kreise, Linien, ...
Ausserdem beinhaltet sie eine Textausgabe und Funktionen um Surfaces zu rotieren und zu zoomen.
<pre>
cd ~
wget http://www.ferzkopp.net/Software/SDL_gfx-2.0/SDL_gfx-2.0.21.tar.gz
tar xvfz SDL_gfx-2.0.21.tar.gz
cd SDL_gfx-2.0.21
RANLIB=/usr/local/arm/4.3.2/bin/arm-linux-ranlib CROSS_COMPILE=arm-linux- ./configure --host=arm-linux --prefix=/usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/ --disable-mmx
time make
sudo make install
</pre>

Micro2440

2010-07-24T14:37:02Z

Kruemeltee: /* Kernel aus den Quellen compilieren */

= Micro2440 =
--[[Benutzer:Theborg0815|Theborg0815]] 19:46, 3. Jul. 2010 (UTC)
[http://www.friendlyarm.net/products/micro2440 Micro2440 von FriendlyARM]

Das Micro2440 ist im Prinzip wie das [http://www.mikrocontroller.net/articles/Mini2440 Mini2440] nur das es keine 64/128MB Flash Variante gibt.
Aufgebaut ist es als Stamp-Modul, welches meistens mit einem SDK-Board, der Peripherie und wahlweise einem 3,5" / 7" TFT oder einen LCD2VGA Adapter kombiniert wird.

=== Technische Daten (Stamp Modul) ===

[[Datei:Micro2440.jpg|350px|right]]

'''Dimension:''' 63 x 52 mm
'''CPU:''' 400 MHz Samsung S3C2440A ARM920T (Max freq. 533 MHz)
'''RAM:''' 64 MB SDRAM, 32 bit 100 MHz Bus
'''Flash:''' 64 MB / 128 MB / 256 MB / 1GB NAND Flash and 2 MB NOR Flash with BIOS
'''User Outputs:''' 4x LEDs Expansion headers (2.0mm)
'''Debug:''' 10 pin JTAG (2.0mm)
'''OS Support:''' Android, Linux 2.6, Windows CE 5 and 6

=== Technische Daten (SDK-Board) ===

[[Datei:Micro2440-SDK.jpg|350px|right]]

'''Dimension:''' 180 x 130 mm
'''EEPROM:''' 1024 Byte 24C08 (I2C)
'''Ext. Memory:''' SD-Card socket
'''Serial Ports:''' 3x DB9 connector (RS232)
'''USB:''' 4x USB-A Host, 1x USB-B Device
'''Audio Output:''' 3.5 mm stereo jack
'''Audio Input:''' 3.5mm jack (mono)
'''Ethernet:''' RJ-45 10/100M (DM9000)
'''RTC:''' Real Time Clock with battery
'''Beeper:''' PWM buzzer
'''Camera:''' 20 pin Camera interface
'''LCD:''' Connector for FriendlyARM Displays (3,5" and 7") and VGA Board
'''Touch Panel:''' 4 pin
'''User Inputs:''' 6x push buttons and 1x A/D pot
'''Expansion header''' (2.0mm)
'''Power:''' 5V connector, power switch and LED

= Software =
== U-Boot ==
==== U-Boot aus den Quellen bauen ====

Leider kann der vivi-Bootlader nicht viel. Vivi unterstützt nur yaffs2 Kernel Images, daher ist es sinnvoll diesen durch den U-Boot-Bootloader auszutauschen. Ich benutze U-Boot aus dem OPENMOKO Projekt für das Micro2440 mit 256MB.

Der compilierte U-Boot-Bootloader ist zu finden unter:[[Datei:uBoot-256MB.bin]].

Für den Anfang sollte abgewogen werden, ob der vivi-Bootloader reicht. Im Fehlerfall kann dieser per JTAG wieder eingespielt werden.

Voraussetzungen dafür ist ein Cross-Compiler z.B. der von [http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 Codesourcery].

Im ersten Schritt muss das Build-Verzeichnis angelegt werden und das git-Repository heruntergeladen werden.. Das geschieht mit den Befehlen:
<c>
mkdir uboot ; cd uboot
git clone git://repo.or.cz/u-boot-openmoko/mini2440.git
</c>
Danach müssen die Source-Dateien für das micro2440 eingestellt und compiliert werden:
<c>
cd mini2440
export CROSS_COMPILE=arm-none-linux-gnueabi-
make mini2440_config
make all
</c>

==== U-Boot Flash’en ====

Den Bootswitch S2 auf NOR stellen, sobald vivi erscheint "q" (in der vivi Konsole) drücken.

Damit U-Boot ab der Adresse 0x32000000 programmiert wird, muss der folgende Befehl eingeben werden:
<c>
load ram 0x32000000 <uboot bin file grösse in bytes> u-boot
</c>
Nun wartet Vivi auf die Datei. In der Shell wird das hochladen mit dem folgenden Befehl initiiert. Die Dateiübertragung erfolgt über USB.
<c>
sudo s3c2410_boot_usb u-boot.bin
</c>
Als nächstes soll das U-Boot gestartet werden. Dazu muss an die Speicherstelle gesprungen werden, an der das U-Boot programmiert wurde. Dies wird mit dem folgendem Befehl erreicht:
<c>
go 0x32000000
</c>
Waren alle vorherigen Schritte erfolgreich, sollte nun die U-Boot Konsole angezeigt werden.(MINI2440#). Anschließend wird nun der NAND-Flash vorbereitet

Zuerst muss das NAND-Flash gelöscht werden, dies wird mit dem folgendem Befehl erreicht:
<c>
nand scrub
</c>
Danach wird die Bad-Block Tabelle erstellt, dies kann etwas Zeit in Anspruch nehmen:
<c>
nand createbbt
</c>
Damit U-Boot in das Flash geschrieben wird, muss folgender Befehl ausgeführt werden.
<c>
nand write.e 0x32000000 0x0 <uBoot bin grösse in hex>
</c>
Für das Partitionieren des Flashs dient der Befehl:
<c>
dynpart
</c>
Environment Speicher einrichten:
<c>
dynenv set u-boot_env
</c>
Enviroment Parameter sichern:
<c>
saveenv
</c>
Nachdem alle Schritte durchgeführt wurden, muss nur noch das Bord ausgeschaltet werden und S2 wieder auf NAND gestellt werden. Nach dem Einschalten sollte euch nun das U-Boot begrüßen.

== Kernel/Filesystem ==
=== Kernel aus den Quellen compilieren ===
Jetzt steht man vor der Wahl welchen Kernel man nimmt. Egal ob EMDebian, Gentoo oder Android, man braucht ihn so oder so. Die fertigen Kernel von [http://www.friendlyarm.net/downloads FriendlyARM] können nur VFAT und JFFS2 daher eignen sich diese nur bedingt für ein System z.b. auf SD/USBStick oder Ext. Platte. Daher ist es sinnvoll sich selbst einen Kernel zu bauen, was nicht schwer ist.

Als erstes besorgen wir uns die Kernel-Quellen und entpacken sie:

==== Gentoo/emDebian ====
<pre>
$ mkdir micro2440
$ cd micro2440
$ git clone git://repo.or.cz/linux-2.6/mini2440.git linux-2.6.32-rc8
</pre>

==== Android ====
<pre>
$ mkdir android
$ cd android
$ git clone git://gitorious.org/android-mini2440/kernel-opencsbc.git
</pre>

Als nächstes laden wir die Default Config und erstellen die .Config für das Micro2440:
<pre>
$ cd linux-2.6.32-rc8
$ CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make mini2440_defconfig
</pre>

Wenn man noch etwas ändern möchte (z.b. ext3-Treiber) startet man "menuconfig":
<pre>
$ CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make menuconfig
</pre>
Den Kernel anschließend compilieren:
<pre>
$ CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make
</pre>
Später kann man noch die Module auf die SD-Karte kopieren:
<pre>
$ CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm INSTALL_MOD_PATH=/mnt make modules_install
</pre>
Als letztes muss das Kernel Image für U-Boot vorbereitet werden. Aus dem zImage (gzip komprimiertes Kernel-Image) wird ein uImage für U-Boot so erstellt:
<pre>
cd .../arch/arm/boot
mkimage -A arm -O linux -T kernel -C none -a 0x30008000 -e 0x30008000 -d zImage uImage
</pre>

=== Filesystem erstellen ===
Als erstes brauchen wir ein RootFS dieses brauchen wir um später die Partition damit zu füllen.

==== emDebian ====
<c>
mkdir armel-rootfs
debootstrap --verbose --arch armel --foreign lenny armel-rootfs http://ftp.de.debian.org/debian
cd armel-rootfs
tar cfjv ../armel-rootfs.tar.bz2 *
</c>

==== Gentoo ====
http://distfiles.gentoo.org/releases/arm/autobuilds/current-stage3/armv4tl-softfloat-linux-gnueabi/stage3-armv4tl-20100620.tar.bz2

==== Android ====
<c>
mkdir android
cd android
git clone git://gitorious.org/android-mini2440/android-mini2440.git
cd android-mini2440
tar cfjv ../android-rootfs.tar.bz2 *
</c>

== Speichermedien vorbereiten ==
=== SD-Karte und USB Medien ===
Als nächstes bereiten wir ein Speichermedium vor, wir brauchen 3 Partitionen, 2x EXT2 und einmal Swap das Beispiel gilt für eine 2GB SD-Karte.

Das machen wir am besten mit fdisk in der Konsole, man kann auch gparted(Grafisch) nutzen aber komischerweise mountet dann bei mir das RootFS nicht ebenso wenn das RootFS ext3 ist, so wie ich raus gefunden habe geht das nur mit SDHC Karten also SD-Karten mit Speicher der >2GB ist.
<c>
fdisk /dev/<Bezeichnung der SD-Karte>
</c>
Der Rest ist recht einfach, einfach folgendes eingeben: dp1 np1 <enter> +20MB <enter> np2 +1800MB <enter> np3 <enter> <enter>

Danach mit p schauen ob alle 3 Partitionen erstellt wurden und mit w Speichern und fdisk beenden.

Jetzt müssen wir noch die Partitionen Formatieren(für ext3 muss noch -j in der zweiten Zeile angegeben werden):
<c>
mke2fs /dev/<Bezeichnung der SD-Karte>1
mke2fs /dev/<Bezeichnung der SD-Karte>2
mkswap /dev/<Bezeichnung der SD-Karte>3
</c>

=== BootFS/RootFS einrichten ===

Dieses ist bei allen Distributionen gleich als erstes kopieren wir den Kernel auf das Speichermedium.
<c>
mount /dev/<Bezeichnung der SD-Karte>1 /mnt
cp ../linux-2.6.32-rc8/arch/arm/boot/uImage /mnt
sync
umount /dev/<Bezeichnung der SD-Karte>1
</c>
Jetzt muss noch das RootFS erstellt werden:
<c>
mount /dev/<Bezeichnung der SD-Karte>2 /mnt
tar xvzfop /path/to/downloaded/<RootFSfile> -C /mnt
sync
umount /dev/<Bezeichnung der SD-Karte>2
</c>

== uBoot ENVs einrichten ==
So jetzt sind wir fast fertig nur das Wichtigste fehlt noch, wir müssen dem Bootlader noch sagen wo er den Kernel findet und dem Kernel wo er das RootFS findet.

Dazu drücken wir eine Taste um denn Autoboot zu unterbrechen und stellen folgendes ein:
<c>
setenv bootcmd mmcinit ; ext2load mmc 0:1 0x31000000 uImage ; bootm 0x31000000
setenv bootargs noinitrd mini2440=1tb rootfstype=ext2 root=/dev/mmcblk0p2 rw rootwait
saveenv
</c>

Bei Android muss noch ein "init=linuxrc" in die zweite Zeile eingefügt werden.

So das war es wen ihr alles durchgearbeitet habt könnt ihr die SD-Karte in den Slot stecken und denn Reset drücken danach sollte das Bord booten.

== Tips/Tricks/Files ==
=== emDebian/Gentoo ===
==== /etc/fstab ====
Beispiel der /etc/fstab: [[Datei:fstab.txt]]

==== /etc/X11/xorg.conf ====
Beispiel xorg.conf fürs 7" Display: [[Datei:xorg.conf.txt]]

==== Touchscreen kalibrieren ====

Folgende Zeile zur /etc/X11/xorg.conf bei [Section "InputDevice"]
hinzufügen.
<c>
Option "Calibrate" "1"
</c>
Und dann noch folgendes machen:
<c>
apt-get install xserver-xorg-input-evtouch
cp /usr/share/xf86-input-evtouch/empty_cursor.xbm /
cd /usr/lib/xf86-input-evtouch
sh calibrate.sh
</c>

Mit folgenden Einträgen in die /etc/X11/xorg.conf bei [Section "InputDevice"] kann man jetzt erst mal die kreuze ausrichten (Siehe Bild.)

[[Datei:touch.jpg|300px|right]]

<c>
Option "x0" "0"
Option "y0" "0"
Option "x1" "0"
Option "y1" "0"
Option "x2" "0"
Option "y2" "0"
Option "x3" "0"
Option "y3" "0"
Option "x4" "0"
Option "y4" "0"
Option "x5" "0"
Option "y5" "0"
Option "x6" "0"
Option "y6" "0"
Option "x7" "0"
Option "y7" "0"
Option "x8" "0"
Option "y8" "0"
</c>
Als nächstes muss man noch die Min/Max werte ermitteln dazu Links unten und oben rechts die Min/Max werte in die xorg.conf übertragen.
<c>
Option "MinX" "153"
Option "MinY" "78"
Option "MaxX" "873"
Option "MaxY" "937"
</c>
Beim 7" Display muss man jetzt nur noch der SW sagen das der Touchscreen Falschrum verbaut ist dieses geht mit folgenden Eintrag in die xorg.conf.
<c>
Option "SwapY" "2"
Option "SwapX" "2"
</c>
Jetzt noch den Eintrag [Option "Calibrate" "1"] wieder aus der xorg.conf raus schmeißen dann sollte alles funktionieren.

==== Konsole auf dem TFT und Seriell ausgeben ====
<c>
echo ttySAC0 >>etc/securetty
printf "T0:123:respawn:/sbin/getty 115200 ttySAC0\n" >> /etc/inittab
</c>

==== Virtuelle Maus ====

Wer lieber mit einer Maus arbeitet und ein iPOD/iPhone besitzt kann RemotePad benutzen einfach aus dem Appstore Laden (Kostenlos), den Quellcode für die Anwendung gibt es unter http://www.tenjin.org/RemotePad/ dieser lässt sich recht einfach auf dem Board oder in einem Buildroot compilieren.

==== Bildschirmtastatur ====

Als Bildschirmtastatur kann man xvkbd verwenden, bei Xfce z.b. einfach einen Link dazu in dem Autostart Ordner erstellen damit es beim Start von xfce geladen wird.

<c>
apt-get install xvkbd
ln /usr/bin/xvkbd ~/.config/autostart
</c>

=== Android ===
=== Sonstiges ===
==== SD-Karte/USB-LW Backupen/Restore ====
===== Backup =====
<c>
dd if=/dev/<Geräte Bezeichung> of=sd2gb.img
</c>

===== Restore =====
<c>
dd if=sd2gb.img of=/dev/<Geräte Bezeichung>
</c>

===== Restore 2GB Backup -> 4/8/16...GB SD-Karte =====
<c>
dd if=sd2gb.img of=/dev/<Geräte Bezeichung>
</c>
Und danach mit gparted die swap Partition Löschen danach die RootFS Partition vergrößern und eine neue swap erstellen.

= Hardware =
[[Datei:microsdkbesch.png|450px|right]]
== Connector / GPIO Belegung ==
=== SDK-Board ===
==== RS232/TTL(CON1-3) ====

{| class="wikitable"
|-
! PIN || CON1 || CON2 || CON3 || RS232(1) || RS232(2) || RS232(3)
|-
| 1 || TXD0 || TXD1 || TXD2 || || ||
|-
| 2 || RXD0 || RXD1 || RXD2 || RSTXD0 || RSTXD1 || RSTXD2
|-
| 3 || VDD5V || VDD5V || VDD5V || RSRXD0 || RSRXD1 || RSRXD2
|-
| 4 || GND || GND || GND || || ||
|-
| 5 || || || || GND || GND || GND
|-
| 7 || || || || RSCTS0 || ||
|-
| 8 || || || || RSRTS0 || ||
|}

==== CON8/Taster ====

{| class="wikitable"
|-
! PIN || CON8 || Taster || GPIO
|-
| 1 || EINT8 || K1 || GPG0/?
|-
| 2 || EINT11 || K2 || GPG3/nSS1
|-
| 3 || EINT13 || K3 || GPG5/SPIMISO1
|-
| 4 || EINT14 || K4 || GPG6/SPIMOSI1
|-
| 5 || EINT15 || K5 || GPG7/SPICLK1
|-
| 6 || EINT19 || K6 || GPG11/TCLK1
|-
| 7 || VDD33V || || 3,3V
|-
| 8 || GND || || GND
|}

==== CON6 ====

{| class="wikitable"
|-
! PIN || CON6 || GPIO ||PIN || CON6 || GPIO
|-
| 1 || VDD5V || 5V || 2 || VDD33V || 3,3V
|-
| 3 || GND || GND || 4 || nRESET || Reset
|-
| 5 || AIN0 || AD0 || 6 || AIN1 || AD1
|-
| 7 || AIN2 || AD2 || 8 || ? || ?
|-
| 9 || EINT0 || GPF0 || 10 || EINT1 || GPF1
|-
| 11 || EINT2 || GPF2 || 12 || EINT3 || GPF3
|-
| 13 || EINT4 || GPF4 || 14 || EINT5 || GPF5
|-
| 15 || EINT6 || GPF6 || 16 || EINT8 || GPG0
|-
| 17 || EINT17 || GPG7/nRST1 || 18 || EINT18 || GPE10/nCTS1
|-
| 19 || I2CSCL || I2CSCL/GPE14 || 20 || I2CSDA || I2CSDA/GPE15
|}

==== CON4/CMOS Camera ====

{| class="wikitable"
|-
! PIN || CON4 || GPIO || PIN || CON4 || GPIO
|-
| 1 || I2CSDA || GPE15 || 2 || I2CSCL || GPE14
|-
| 3 || EINT20 || GPG12 || 4 || CAMRST || GPJ12
|-
| 5 || CAMCLK || GPJ11 || 6 || CAM_HRES || GPJ10
|-
| 7 || CAM_VSYNC || GPJ9 || 8 || CAM_PCLK || GPJ8
|-
| 9 || CAMDATA7 || GPJ7 || 10 || CAMDATA6 || GPJ6
|-
| 11 || CAMDATA5 || GPJ5 || 12 || CAMDATA4 || GPJ4
|-
| 13 || CAMDATA3 || GPJ3 || 14 || CAMDATA2 || GPJ2
|-
| 15 || CAMDATA1 || GPJ1 || 16 || CAMDATA0 || GPJ0
|-
| 17 || VDD33V || 3,3V || 18 || VDD_CAM || VDD_CAM
|-
| 19 || VDD18V || 1,8V || 20 || GND || GND
|}

==== CON9/10 Touchscreen ====

{| class="wikitable"
|-
! PIN || CON9 || CON10 || GPIO
|-
| 1 || TSXM || TSXM || ?
|-
| 2 || TSYM || TSYM || ?
|-
| 3 || TSXP || TSXP || ?
|-
| 4 || TSYP || TSYP || ?
|}

==== CON5 ====

{| class="wikitable"
|-
! PIN || CON5 || GPIO || PIN || CON5 || GPIO
|-
| 1 || EINT17 || GPG7/nRST1 || 2 || EINT18 || nCTS1
|-
| 3 || nGCS1 || || 4 || EINT8 || GPG0
|-
| 5 || nGSC2 || || 6 || LnWBE1 ||
|-
| 7 || nGSC3 || || 8 || LnWE ||
|-
| 9 || LnOE || || 10 || nRESET ||
|-
| 11 || nWAIT || || 12 || nXDACK0 ||
|-
| 13 || LADDR0 || || 14 || nXDRWQ0 ||
|-
| 15 || LADDR1 || || 16 || LADDR2 ||
|-
| 17 || LADDR3 || || 18 || LADDR4 ||
|-
| 19 || LADDR5 || || 20 || LADDR6 ||
|-
| 21 || LADDR7 || || 22 || LADDR8 ||
|-
| 23 || LADDR9 || || 24 || LADDR10 ||
|-
| 25 || LADDR11 || || 26 || LADDR12 ||
|-
| 27 || LADDR13 || || 28 || LADDR14 ||
|-
| 29 || LADDR15 || || 30 || LADDR16 ||
|-
| 31 || LADDR17 || || 32 || LADDR18 ||
|-
| 33 || LADDR19 || || 34 || LADDR20 ||
|-
| 35 || LADDR21 || || 36 || LADDR22 ||
|-
| 37 || LADDR23 || || 38 || LADDR24 ||
|-
| 39 || LDATA0 || || 40 || DATA1 ||
|-
| 41 || LDATA2 || || 42 || DATA3 ||
|-
| 43 || LDATA4 || || 44 || DATA5 ||
|-
| 45 || LDATA6 || || 46 || DATA7 ||
|-
| 47 || LDATA8 || || 48 || DATA9 ||
|-
| 49 || LDATA10 || || 50 || DATA11 ||
|-
| 51 || LDATA12 || || 52 || DATA13 ||
|-
| 53 || LDATA14 || || 54 || DATA15 ||
|-
| 55 || VDD5V || 5V || 56 || GND || GND
|}

==== LCD0/LCD1 ====
{| class="wikitable"
|-
! PIN || LCD1 || LCD0 || PIN || LCD1 || LCD0
|-
| 1 || VDD5V || VDDLED5V || 2 || VDD5V || VDDLED5V
|-
| 3 || VD0 || ADJ || 4 || VD1 || GND
|-
| 5 || VD2 || GND || 6 || VD3 || VDD33V
|-
| 7 || VD4 || VDD33V || 8 || VD5 || MODE(DE/HV)
|-
| 9 || VD6 || VM/DE || 10 || VD7 || VFRAME
|-
| 11 || GND || VLINE || 12 || VD8 || GND
|-
| 13 || VD9 || VD7/B5 || 14 || VD10 || VD6/BD
|-
| 15 || VD11 || VD5/B3 || 16 || VD12 || GND
|-
| 17 || VD13 || VD4/B2 || 18 || VD14 || VD3/B1
|-
| 19 || VD15 || VD2/B0 || 20 || GND || GND
|-
| 21 || VD16 || VD15/G5 || 22 || VD17 || VD14/G4
|-
| 23 || VD18 || VD13/G3 || 24 || VD19 || GND
|-
| 25 || VD20 || VD12/G2 || 26 || VD21 || VD11/G1
|-
| 27 || VD22 || VD10/G0 || 28 || VD23 || GND
|-
| 29 || GND || VD23/R5 || 30 || LCD_PWR|| VD22/R4
|-
| 31 || GPB1 || VD21/R3 || 32 || nRESET || GND
|-
| 33 || VM || VD20/R2 || 34 || VFRAME || VD19/R1
|-
| 35 || VLINE || VD18/R0 || 36 || VCLK || GND
|-
| 37 || TSXM || VCLK || 38 || TSXP || GND
|-
| 39 || TSYM || L/R || 40 || TSYP || U/D
|-
| 41 || ? || || || ||
|}

=== Stamp-Modul ===

==== JTAG ====

{| class="wikitable"
|-
! PIN || GPIO || PIN || GPIO
|-
| 1 || VDD33V || 2 || VDD33V
|-
| 3 || nTRST || 4 || nRESET
|-
| 5 || TDI || 6 || TDO
|-
| 7 || TMS || 8 || GND
|-
| 9 || TCK || 10 || GND
|}

==== PA.1 ====

==== PB.1 ====

==== PC.1 ====

== Peripherie Beschaltung ==

=== SDK-Bord ===

=== Stamp-Modul ===

== Selbstbau Peripherie ==

= Links/Downloads =

== Software ==
[http://code.google.com/p/mini2440/downloads/detail?name=s3c2410_boot_usb-20060807.tar.bz2&can=2&q= s3c2410 USB DL Tool für Linux]
[http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 Crosscompiler von CodeSourcery]

== Hardware ==
[http://www.electronics.diycinema.co.uk/ Einige Basteleien (Tempsensor, RGB Treiber, MEMS ...]

== Datenblätter ==
[http://www.friendlyarm.net/dl.php?file=micro2440_manual_20100204.pdf Anleitung(Chinesisch)]
[http://www.friendlyarm.net/dl.php?file=micro2440_dimension.pdf Dimension Stamp-Modul]
[http://www.friendlyarm.net/dl.php?file=micro2440_schematic.zip Micro2440 + SDK-Schaltplan]
[http://www.friendlyarm.net/dl.php?file=lcd70_schematic.zip 7" LCD Schaltplan]
[http://www.friendlyarm.net/dl.php?file=lcd35_schematic.zip 3,5" LCD Schaltplan]

== Händler ==
[http://www.watterott.com/de/FriendlyARM Bezugsquelle Watterott]

[[Category:ARM-Boards]][[Category:ARM]][[Category:Linux]]

Micro2440

2010-07-24T14:31:29Z

Kruemeltee: /* Micro2440 */

= Micro2440 =
--[[Benutzer:Theborg0815|Theborg0815]] 19:46, 3. Jul. 2010 (UTC)
[http://www.friendlyarm.net/products/micro2440 Micro2440 von FriendlyARM]

Das Micro2440 ist im Prinzip wie das [http://www.mikrocontroller.net/articles/Mini2440 Mini2440] nur das es keine 64/128MB Flash Variante gibt.
Aufgebaut ist es als Stamp-Modul, welches meistens mit einem SDK-Board, der Peripherie und wahlweise einem 3,5" / 7" TFT oder einen LCD2VGA Adapter kombiniert wird.

=== Technische Daten (Stamp Modul) ===

[[Datei:Micro2440.jpg|350px|right]]

'''Dimension:''' 63 x 52 mm
'''CPU:''' 400 MHz Samsung S3C2440A ARM920T (Max freq. 533 MHz)
'''RAM:''' 64 MB SDRAM, 32 bit 100 MHz Bus
'''Flash:''' 64 MB / 128 MB / 256 MB / 1GB NAND Flash and 2 MB NOR Flash with BIOS
'''User Outputs:''' 4x LEDs Expansion headers (2.0mm)
'''Debug:''' 10 pin JTAG (2.0mm)
'''OS Support:''' Android, Linux 2.6, Windows CE 5 and 6

=== Technische Daten (SDK-Board) ===

[[Datei:Micro2440-SDK.jpg|350px|right]]

'''Dimension:''' 180 x 130 mm
'''EEPROM:''' 1024 Byte 24C08 (I2C)
'''Ext. Memory:''' SD-Card socket
'''Serial Ports:''' 3x DB9 connector (RS232)
'''USB:''' 4x USB-A Host, 1x USB-B Device
'''Audio Output:''' 3.5 mm stereo jack
'''Audio Input:''' 3.5mm jack (mono)
'''Ethernet:''' RJ-45 10/100M (DM9000)
'''RTC:''' Real Time Clock with battery
'''Beeper:''' PWM buzzer
'''Camera:''' 20 pin Camera interface
'''LCD:''' Connector for FriendlyARM Displays (3,5" and 7") and VGA Board
'''Touch Panel:''' 4 pin
'''User Inputs:''' 6x push buttons and 1x A/D pot
'''Expansion header''' (2.0mm)
'''Power:''' 5V connector, power switch and LED

= Software =
== U-Boot ==
==== U-Boot aus den Quellen bauen ====

Leider kann der vivi-Bootlader nicht viel. Vivi unterstützt nur yaffs2 Kernel Images, daher ist es sinnvoll diesen durch den U-Boot-Bootloader auszutauschen. Ich benutze U-Boot aus dem OPENMOKO Projekt für das Micro2440 mit 256MB.

Der compilierte U-Boot-Bootloader ist zu finden unter:[[Datei:uBoot-256MB.bin]].

Für den Anfang sollte abgewogen werden, ob der vivi-Bootloader reicht. Im Fehlerfall kann dieser per JTAG wieder eingespielt werden.

Voraussetzungen dafür ist ein Cross-Compiler z.B. der von [http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 Codesourcery].

Im ersten Schritt muss das Build-Verzeichnis angelegt werden und das git-Repository heruntergeladen werden.. Das geschieht mit den Befehlen:
<c>
mkdir uboot ; cd uboot
git clone git://repo.or.cz/u-boot-openmoko/mini2440.git
</c>
Danach müssen die Source-Dateien für das micro2440 eingestellt und compiliert werden:
<c>
cd mini2440
export CROSS_COMPILE=arm-none-linux-gnueabi-
make mini2440_config
make all
</c>

==== U-Boot Flash’en ====

Den Bootswitch S2 auf NOR stellen, sobald vivi erscheint "q" (in der vivi Konsole) drücken.

Damit U-Boot ab der Adresse 0x32000000 programmiert wird, muss der folgende Befehl eingeben werden:
<c>
load ram 0x32000000 <uboot bin file grösse in bytes> u-boot
</c>
Nun wartet Vivi auf die Datei. In der Shell wird das hochladen mit dem folgenden Befehl initiiert. Die Dateiübertragung erfolgt über USB.
<c>
sudo s3c2410_boot_usb u-boot.bin
</c>
Als nächstes soll das U-Boot gestartet werden. Dazu muss an die Speicherstelle gesprungen werden, an der das U-Boot programmiert wurde. Dies wird mit dem folgendem Befehl erreicht:
<c>
go 0x32000000
</c>
Waren alle vorherigen Schritte erfolgreich, sollte nun die U-Boot Konsole angezeigt werden.(MINI2440#). Anschließend wird nun der NAND-Flash vorbereitet

Zuerst muss das NAND-Flash gelöscht werden, dies wird mit dem folgendem Befehl erreicht:
<c>
nand scrub
</c>
Danach wird die Bad-Block Tabelle erstellt, dies kann etwas Zeit in Anspruch nehmen:
<c>
nand createbbt
</c>
Damit U-Boot in das Flash geschrieben wird, muss folgender Befehl ausgeführt werden.
<c>
nand write.e 0x32000000 0x0 <uBoot bin grösse in hex>
</c>
Für das Partitionieren des Flashs dient der Befehl:
<c>
dynpart
</c>
Environment Speicher einrichten:
<c>
dynenv set u-boot_env
</c>
Enviroment Parameter sichern:
<c>
saveenv
</c>
Nachdem alle Schritte durchgeführt wurden, muss nur noch das Bord ausgeschaltet werden und S2 wieder auf NAND gestellt werden. Nach dem Einschalten sollte euch nun das U-Boot begrüßen.

== Kernel/Filesystem ==
=== Kernel aus den Quellen compilieren ===
Jetzt steht man vor der Wahl welchen Kernel man nimmt egal ob EMDebian, Gentoo oder Android brauchen tut man ihn so oder so, die fertigen Kernel von friendlyarm.net können nur VFAT,JFFS2 daher eignen sich diese nur bedingt für ein System z.b. auf SD/USBStick oder Ext. Platte, Also ist es sinnvoll diesen sich selber zu bauen dieses ist nicht wirklich schwer.

Als erstes Besorgen wir uns den Kernel und entpacken ihn:

==== Gentoo/emDebian ====
<c>
mkdir micro2440
cd micro2440
git clone git://repo.or.cz/linux-2.6/mini2440.git linux-2.6.32-rc8
</c>

==== Android ====
<c>
mkdir android
cd android
git clone git://gitorious.org/android-mini2440/kernel-opencsbc.git
</c>

Als nächstes laden wir die Default Config und erstellen die .Config für das Micro2440:
<c>
cd linux-2.6.32-rc8
CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make mini2440_defconfig
</c>

Wenn man noch etwas ändern möchte z.b. ext3 Kernelmodule etc.:
<c>
CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make menuconfig
</c>
Den Kernel anschließend compilieren:
<c>
CROSS_COMPILE=arm-none-linux-gnueabi- ARCH=arm make
</c>
Später kann man noch die Module auf die SD-Karte kopieren:
<c>
CROSS_COMPILE=arm-softfloat-linux-gnueabi- ARCH=arm INSTALL_MOD_PATH=/mnt make modules_install
</c>
Als letztes muss das Kernel Image für U-Boot vorbereitet werden d.h. aus dem vImage(für vivi) wird ein uImage für U-Boot angelegt.
<c>
cd .../arch/arm/boot
mkimage -A arm -O linux -T kernel -C none -a 0x30008000 -e 0x30008000 -d zImage uImage
</c>

=== Filesystem erstellen ===
Als erstes brauchen wir ein RootFS dieses brauchen wir um später die Partition damit zu füllen.

==== emDebian ====
<c>
mkdir armel-rootfs
debootstrap --verbose --arch armel --foreign lenny armel-rootfs http://ftp.de.debian.org/debian
cd armel-rootfs
tar cfjv ../armel-rootfs.tar.bz2 *
</c>

==== Gentoo ====
http://distfiles.gentoo.org/releases/arm/autobuilds/current-stage3/armv4tl-softfloat-linux-gnueabi/stage3-armv4tl-20100620.tar.bz2

==== Android ====
<c>
mkdir android
cd android
git clone git://gitorious.org/android-mini2440/android-mini2440.git
cd android-mini2440
tar cfjv ../android-rootfs.tar.bz2 *
</c>

== Speichermedien vorbereiten ==
=== SD-Karte und USB Medien ===
Als nächstes bereiten wir ein Speichermedium vor, wir brauchen 3 Partitionen, 2x EXT2 und einmal Swap das Beispiel gilt für eine 2GB SD-Karte.

Das machen wir am besten mit fdisk in der Konsole, man kann auch gparted(Grafisch) nutzen aber komischerweise mountet dann bei mir das RootFS nicht ebenso wenn das RootFS ext3 ist, so wie ich raus gefunden habe geht das nur mit SDHC Karten also SD-Karten mit Speicher der >2GB ist.
<c>
fdisk /dev/<Bezeichnung der SD-Karte>
</c>
Der Rest ist recht einfach, einfach folgendes eingeben: dp1 np1 <enter> +20MB <enter> np2 +1800MB <enter> np3 <enter> <enter>

Danach mit p schauen ob alle 3 Partitionen erstellt wurden und mit w Speichern und fdisk beenden.

Jetzt müssen wir noch die Partitionen Formatieren(für ext3 muss noch -j in der zweiten Zeile angegeben werden):
<c>
mke2fs /dev/<Bezeichnung der SD-Karte>1
mke2fs /dev/<Bezeichnung der SD-Karte>2
mkswap /dev/<Bezeichnung der SD-Karte>3
</c>

=== BootFS/RootFS einrichten ===

Dieses ist bei allen Distributionen gleich als erstes kopieren wir den Kernel auf das Speichermedium.
<c>
mount /dev/<Bezeichnung der SD-Karte>1 /mnt
cp ../linux-2.6.32-rc8/arch/arm/boot/uImage /mnt
sync
umount /dev/<Bezeichnung der SD-Karte>1
</c>
Jetzt muss noch das RootFS erstellt werden:
<c>
mount /dev/<Bezeichnung der SD-Karte>2 /mnt
tar xvzfop /path/to/downloaded/<RootFSfile> -C /mnt
sync
umount /dev/<Bezeichnung der SD-Karte>2
</c>

== uBoot ENVs einrichten ==
So jetzt sind wir fast fertig nur das Wichtigste fehlt noch, wir müssen dem Bootlader noch sagen wo er den Kernel findet und dem Kernel wo er das RootFS findet.

Dazu drücken wir eine Taste um denn Autoboot zu unterbrechen und stellen folgendes ein:
<c>
setenv bootcmd mmcinit ; ext2load mmc 0:1 0x31000000 uImage ; bootm 0x31000000
setenv bootargs noinitrd mini2440=1tb rootfstype=ext2 root=/dev/mmcblk0p2 rw rootwait
saveenv
</c>

Bei Android muss noch ein "init=linuxrc" in die zweite Zeile eingefügt werden.

So das war es wen ihr alles durchgearbeitet habt könnt ihr die SD-Karte in den Slot stecken und denn Reset drücken danach sollte das Bord booten.

== Tips/Tricks/Files ==
=== emDebian/Gentoo ===
==== /etc/fstab ====
Beispiel der /etc/fstab: [[Datei:fstab.txt]]

==== /etc/X11/xorg.conf ====
Beispiel xorg.conf fürs 7" Display: [[Datei:xorg.conf.txt]]

==== Touchscreen kalibrieren ====

Folgende Zeile zur /etc/X11/xorg.conf bei [Section "InputDevice"]
hinzufügen.
<c>
Option "Calibrate" "1"
</c>
Und dann noch folgendes machen:
<c>
apt-get install xserver-xorg-input-evtouch
cp /usr/share/xf86-input-evtouch/empty_cursor.xbm /
cd /usr/lib/xf86-input-evtouch
sh calibrate.sh
</c>

Mit folgenden Einträgen in die /etc/X11/xorg.conf bei [Section "InputDevice"] kann man jetzt erst mal die kreuze ausrichten (Siehe Bild.)

[[Datei:touch.jpg|300px|right]]

<c>
Option "x0" "0"
Option "y0" "0"
Option "x1" "0"
Option "y1" "0"
Option "x2" "0"
Option "y2" "0"
Option "x3" "0"
Option "y3" "0"
Option "x4" "0"
Option "y4" "0"
Option "x5" "0"
Option "y5" "0"
Option "x6" "0"
Option "y6" "0"
Option "x7" "0"
Option "y7" "0"
Option "x8" "0"
Option "y8" "0"
</c>
Als nächstes muss man noch die Min/Max werte ermitteln dazu Links unten und oben rechts die Min/Max werte in die xorg.conf übertragen.
<c>
Option "MinX" "153"
Option "MinY" "78"
Option "MaxX" "873"
Option "MaxY" "937"
</c>
Beim 7" Display muss man jetzt nur noch der SW sagen das der Touchscreen Falschrum verbaut ist dieses geht mit folgenden Eintrag in die xorg.conf.
<c>
Option "SwapY" "2"
Option "SwapX" "2"
</c>
Jetzt noch den Eintrag [Option "Calibrate" "1"] wieder aus der xorg.conf raus schmeißen dann sollte alles funktionieren.

==== Konsole auf dem TFT und Seriell ausgeben ====
<c>
echo ttySAC0 >>etc/securetty
printf "T0:123:respawn:/sbin/getty 115200 ttySAC0\n" >> /etc/inittab
</c>

==== Virtuelle Maus ====

Wer lieber mit einer Maus arbeitet und ein iPOD/iPhone besitzt kann RemotePad benutzen einfach aus dem Appstore Laden (Kostenlos), den Quellcode für die Anwendung gibt es unter http://www.tenjin.org/RemotePad/ dieser lässt sich recht einfach auf dem Board oder in einem Buildroot compilieren.

==== Bildschirmtastatur ====

Als Bildschirmtastatur kann man xvkbd verwenden, bei Xfce z.b. einfach einen Link dazu in dem Autostart Ordner erstellen damit es beim Start von xfce geladen wird.

<c>
apt-get install xvkbd
ln /usr/bin/xvkbd ~/.config/autostart
</c>

=== Android ===
=== Sonstiges ===
==== SD-Karte/USB-LW Backupen/Restore ====
===== Backup =====
<c>
dd if=/dev/<Geräte Bezeichung> of=sd2gb.img
</c>

===== Restore =====
<c>
dd if=sd2gb.img of=/dev/<Geräte Bezeichung>
</c>

===== Restore 2GB Backup -> 4/8/16...GB SD-Karte =====
<c>
dd if=sd2gb.img of=/dev/<Geräte Bezeichung>
</c>
Und danach mit gparted die swap Partition Löschen danach die RootFS Partition vergrößern und eine neue swap erstellen.

= Hardware =
[[Datei:microsdkbesch.png|450px|right]]
== Connector / GPIO Belegung ==
=== SDK-Board ===
==== RS232/TTL(CON1-3) ====

{| class="wikitable"
|-
! PIN || CON1 || CON2 || CON3 || RS232(1) || RS232(2) || RS232(3)
|-
| 1 || TXD0 || TXD1 || TXD2 || || ||
|-
| 2 || RXD0 || RXD1 || RXD2 || RSTXD0 || RSTXD1 || RSTXD2
|-
| 3 || VDD5V || VDD5V || VDD5V || RSRXD0 || RSRXD1 || RSRXD2
|-
| 4 || GND || GND || GND || || ||
|-
| 5 || || || || GND || GND || GND
|-
| 7 || || || || RSCTS0 || ||
|-
| 8 || || || || RSRTS0 || ||
|}

==== CON8/Taster ====

{| class="wikitable"
|-
! PIN || CON8 || Taster || GPIO
|-
| 1 || EINT8 || K1 || GPG0/?
|-
| 2 || EINT11 || K2 || GPG3/nSS1
|-
| 3 || EINT13 || K3 || GPG5/SPIMISO1
|-
| 4 || EINT14 || K4 || GPG6/SPIMOSI1
|-
| 5 || EINT15 || K5 || GPG7/SPICLK1
|-
| 6 || EINT19 || K6 || GPG11/TCLK1
|-
| 7 || VDD33V || || 3,3V
|-
| 8 || GND || || GND
|}

==== CON6 ====

{| class="wikitable"
|-
! PIN || CON6 || GPIO ||PIN || CON6 || GPIO
|-
| 1 || VDD5V || 5V || 2 || VDD33V || 3,3V
|-
| 3 || GND || GND || 4 || nRESET || Reset
|-
| 5 || AIN0 || AD0 || 6 || AIN1 || AD1
|-
| 7 || AIN2 || AD2 || 8 || ? || ?
|-
| 9 || EINT0 || GPF0 || 10 || EINT1 || GPF1
|-
| 11 || EINT2 || GPF2 || 12 || EINT3 || GPF3
|-
| 13 || EINT4 || GPF4 || 14 || EINT5 || GPF5
|-
| 15 || EINT6 || GPF6 || 16 || EINT8 || GPG0
|-
| 17 || EINT17 || GPG7/nRST1 || 18 || EINT18 || GPE10/nCTS1
|-
| 19 || I2CSCL || I2CSCL/GPE14 || 20 || I2CSDA || I2CSDA/GPE15
|}

==== CON4/CMOS Camera ====

{| class="wikitable"
|-
! PIN || CON4 || GPIO || PIN || CON4 || GPIO
|-
| 1 || I2CSDA || GPE15 || 2 || I2CSCL || GPE14
|-
| 3 || EINT20 || GPG12 || 4 || CAMRST || GPJ12
|-
| 5 || CAMCLK || GPJ11 || 6 || CAM_HRES || GPJ10
|-
| 7 || CAM_VSYNC || GPJ9 || 8 || CAM_PCLK || GPJ8
|-
| 9 || CAMDATA7 || GPJ7 || 10 || CAMDATA6 || GPJ6
|-
| 11 || CAMDATA5 || GPJ5 || 12 || CAMDATA4 || GPJ4
|-
| 13 || CAMDATA3 || GPJ3 || 14 || CAMDATA2 || GPJ2
|-
| 15 || CAMDATA1 || GPJ1 || 16 || CAMDATA0 || GPJ0
|-
| 17 || VDD33V || 3,3V || 18 || VDD_CAM || VDD_CAM
|-
| 19 || VDD18V || 1,8V || 20 || GND || GND
|}

==== CON9/10 Touchscreen ====

{| class="wikitable"
|-
! PIN || CON9 || CON10 || GPIO
|-
| 1 || TSXM || TSXM || ?
|-
| 2 || TSYM || TSYM || ?
|-
| 3 || TSXP || TSXP || ?
|-
| 4 || TSYP || TSYP || ?
|}

==== CON5 ====

{| class="wikitable"
|-
! PIN || CON5 || GPIO || PIN || CON5 || GPIO
|-
| 1 || EINT17 || GPG7/nRST1 || 2 || EINT18 || nCTS1
|-
| 3 || nGCS1 || || 4 || EINT8 || GPG0
|-
| 5 || nGSC2 || || 6 || LnWBE1 ||
|-
| 7 || nGSC3 || || 8 || LnWE ||
|-
| 9 || LnOE || || 10 || nRESET ||
|-
| 11 || nWAIT || || 12 || nXDACK0 ||
|-
| 13 || LADDR0 || || 14 || nXDRWQ0 ||
|-
| 15 || LADDR1 || || 16 || LADDR2 ||
|-
| 17 || LADDR3 || || 18 || LADDR4 ||
|-
| 19 || LADDR5 || || 20 || LADDR6 ||
|-
| 21 || LADDR7 || || 22 || LADDR8 ||
|-
| 23 || LADDR9 || || 24 || LADDR10 ||
|-
| 25 || LADDR11 || || 26 || LADDR12 ||
|-
| 27 || LADDR13 || || 28 || LADDR14 ||
|-
| 29 || LADDR15 || || 30 || LADDR16 ||
|-
| 31 || LADDR17 || || 32 || LADDR18 ||
|-
| 33 || LADDR19 || || 34 || LADDR20 ||
|-
| 35 || LADDR21 || || 36 || LADDR22 ||
|-
| 37 || LADDR23 || || 38 || LADDR24 ||
|-
| 39 || LDATA0 || || 40 || DATA1 ||
|-
| 41 || LDATA2 || || 42 || DATA3 ||
|-
| 43 || LDATA4 || || 44 || DATA5 ||
|-
| 45 || LDATA6 || || 46 || DATA7 ||
|-
| 47 || LDATA8 || || 48 || DATA9 ||
|-
| 49 || LDATA10 || || 50 || DATA11 ||
|-
| 51 || LDATA12 || || 52 || DATA13 ||
|-
| 53 || LDATA14 || || 54 || DATA15 ||
|-
| 55 || VDD5V || 5V || 56 || GND || GND
|}

==== LCD0/LCD1 ====
{| class="wikitable"
|-
! PIN || LCD1 || LCD0 || PIN || LCD1 || LCD0
|-
| 1 || VDD5V || VDDLED5V || 2 || VDD5V || VDDLED5V
|-
| 3 || VD0 || ADJ || 4 || VD1 || GND
|-
| 5 || VD2 || GND || 6 || VD3 || VDD33V
|-
| 7 || VD4 || VDD33V || 8 || VD5 || MODE(DE/HV)
|-
| 9 || VD6 || VM/DE || 10 || VD7 || VFRAME
|-
| 11 || GND || VLINE || 12 || VD8 || GND
|-
| 13 || VD9 || VD7/B5 || 14 || VD10 || VD6/BD
|-
| 15 || VD11 || VD5/B3 || 16 || VD12 || GND
|-
| 17 || VD13 || VD4/B2 || 18 || VD14 || VD3/B1
|-
| 19 || VD15 || VD2/B0 || 20 || GND || GND
|-
| 21 || VD16 || VD15/G5 || 22 || VD17 || VD14/G4
|-
| 23 || VD18 || VD13/G3 || 24 || VD19 || GND
|-
| 25 || VD20 || VD12/G2 || 26 || VD21 || VD11/G1
|-
| 27 || VD22 || VD10/G0 || 28 || VD23 || GND
|-
| 29 || GND || VD23/R5 || 30 || LCD_PWR|| VD22/R4
|-
| 31 || GPB1 || VD21/R3 || 32 || nRESET || GND
|-
| 33 || VM || VD20/R2 || 34 || VFRAME || VD19/R1
|-
| 35 || VLINE || VD18/R0 || 36 || VCLK || GND
|-
| 37 || TSXM || VCLK || 38 || TSXP || GND
|-
| 39 || TSYM || L/R || 40 || TSYP || U/D
|-
| 41 || ? || || || ||
|}

=== Stamp-Modul ===

==== JTAG ====

{| class="wikitable"
|-
! PIN || GPIO || PIN || GPIO
|-
| 1 || VDD33V || 2 || VDD33V
|-
| 3 || nTRST || 4 || nRESET
|-
| 5 || TDI || 6 || TDO
|-
| 7 || TMS || 8 || GND
|-
| 9 || TCK || 10 || GND
|}

==== PA.1 ====

==== PB.1 ====

==== PC.1 ====

== Peripherie Beschaltung ==

=== SDK-Bord ===

=== Stamp-Modul ===

== Selbstbau Peripherie ==

= Links/Downloads =

== Software ==
[http://code.google.com/p/mini2440/downloads/detail?name=s3c2410_boot_usb-20060807.tar.bz2&can=2&q= s3c2410 USB DL Tool für Linux]
[http://www.codesourcery.com/sgpp/lite/arm/portal/package3696/public/arm-none-linux-gnueabi/arm-2008q3-72-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 Crosscompiler von CodeSourcery]

== Hardware ==
[http://www.electronics.diycinema.co.uk/ Einige Basteleien (Tempsensor, RGB Treiber, MEMS ...]

== Datenblätter ==
[http://www.friendlyarm.net/dl.php?file=micro2440_manual_20100204.pdf Anleitung(Chinesisch)]
[http://www.friendlyarm.net/dl.php?file=micro2440_dimension.pdf Dimension Stamp-Modul]
[http://www.friendlyarm.net/dl.php?file=micro2440_schematic.zip Micro2440 + SDK-Schaltplan]
[http://www.friendlyarm.net/dl.php?file=lcd70_schematic.zip 7" LCD Schaltplan]
[http://www.friendlyarm.net/dl.php?file=lcd35_schematic.zip 3,5" LCD Schaltplan]

== Händler ==
[http://www.watterott.com/de/FriendlyARM Bezugsquelle Watterott]

[[Category:ARM-Boards]][[Category:ARM]][[Category:Linux]]

Mini2440 SDL GUI Programmierung

2010-07-23T05:59:57Z

Kruemeltee: /* libsdl_gfx */

Wer ein kleines Linuxboard mit Display hat, möchte sicher nicht nur die Kernelausgaben auf der Framebuffer-Konsole ansehen oder sich für die popligsten Anwendungen einen X-Server+Window Manager installieren, sich eine Anwendung schreiben und dann erst loslegen können.

Viel einfacher geht es in einigen Fällen mit [http://www.libsdl.org SDL]. Dieser Artikel beschreibt die Einrichtung einer Cross-Toolchain mit SDL-Support für das [[Mini2440]].
Die unterschiede von Board zu Board sind meist sehr gering, was die Display-Ausgabe angeht. Daher lässt sich dieser Artikel auch für einige andere Boards verwenden.

Hier ein Screenshot von einem meiner SDL-Programme: 
[[Bild:mini2440_sdl_menu_screenshot.png|100px]]

Die Vorraussetzungen hierfür sind:
* Die [http://www.mikrocontroller.net/articles/Mini2440#Toolchain FriendlyARM Toolchain]
* Funktionierender Framebuffer mit Framebuffer Konsole
* Ein wenig Zeit

= Einrichten der Cross-Toolchain =
Ich gehe davon aus, dass man alle kommenden Schritte als "normaler" User erledigt. Sämtliche Schritte, die als "root" erledigt werden müssen, wird ein "sudo" vorangestellt. Wenn das bei dir anders gehen sollte (z.B. su -c '...'), dann ändere es für dich!

== libsdl ==
<pre>
cd ~
wget http://www.libsdl.org/release/SDL-1.2.14.tar.gz
tar xvfz SDL-1.2.14.tar.gz
cd SDL-1.2.14
RANLIB=/usr/local/arm/4.3.2/bin/arm-linux-ranlib CROSS_COMPILE=arm-linux- ./configure --host=arm-linux --prefix=/usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/ \
--enable-input-tslib --enable-video-fbcon --disable-audio --disable-video-x11 --disable-video-directfb
time make
sudo time make install
</pre>
Diese Schritte dauerten bei mir ca 5 Minuten.

Nun lassen sich schon die ersten Programme mittels SDL compilieren. Allerdings fehlen noch zusätzliche libs, wie z.B. [http://www.ferzkopp.net/joomla/content/view/19/14/ sdl_gfx] und [http://www.libsdl.org/projects/SDL_image/ sdl_image] um Grafiken, Texte und Bilder anzeigen zu können. SDL alleine steht da ein wenig auf dem Schlauch.

Einen Haken hat die Sache noch. Dadurch, dass SDL in seinem Audio-Code auch Assembler verwendet habe ich es noch nicht hinbekommen, SDL mit ALSA oder OSS Support zu compilieren.
Wer dazu einen Tip hat, immer her damit :)

== libsdl_image ==
Mit dieser lib lassen sich recht einfach Bilder laden und anzeigen.
<pre>
cd ~
wget http://www.libsdl.org/projects/SDL_image/release/SDL_image-1.2.10.tar.gz
tar xvfz SDL_image-1.2.10.tar.gz
cd SDL_image-1.2.10
RANLIB=/usr/local/arm/4.3.2/bin/arm-linux-ranlib CROSS_COMPILE=arm-linux- ./configure --host=arm-linux --prefix=/usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/ \
--enable-gif --enable-jpg --enable-bmp
***HACK*** (siehe Text unter diesem Kasten)
sudo ln -s /usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/armv4t/usr/lib/libts.la /usr/local/lib/libts.la
sudo ln -s /usr/local/arm/4.3.2/arm-none-linux-gnueabi/libc/armv4t/usr/lib/libts.so /usr/local/lib/libts.so
***/HACK***
time make
sudo time make install
</pre>
Anmerkungen zum "Hack". Beim compilieren spuckt mir SDL_image einen Fehler aus. Es sagt mir, dass er in /usr/local/lib/ die tslib nicht finden kann. Dort hat er aber nichts zu suchen, da dies kein Pfad zum Cross-Compiling ist. Wie ich das abstelle, habe ich noch nicht herausgefunden, also habe ich einfach einen symbolischen Link angelegt.

== libsdl_gfx ==
Diese lib stellt einen Haufen Grafikfuntkionen bereit, wie Polygone, Rechtecke, Kreise, Linien, ...
Ausserdem beinhaltet sie eine Textausgabe und Funktionen um Surfaces zu rotieren und zu zoomen.

== libsdl_ttf ==
Diese lib kann mit TrueType Fonts umegehen und sie anzeigen.

= Verwenden von SDL =
== tslib-Maus ==
== Grafik-Funktionen ==
== Bild-Funktionen ==
== Threads ==