Porterweiterungen

Wechseln zu: Navigation, Suche

von Frank Link (Der Platinenshop)


Vor einiger Zeit habe ich mit Hilfe des Forums eine Ansteuerungsplatine für einen Motorpotentiometer entwickelt. Zum Einsatz kam ein ATMEGA8, da ich kein entsprechendes IC zur Ansteuerung des Motors verwenden wollte, habe ich mehrere Ausgänge eines Ports parallel geschaltet.

Leider blieben dann nur noch fünf Digitalausgänge übrig um weitere Funktionen anzusteuern.

Da ich immer mehr Anfragen hatte die zusätzliche Ein- und Ausgänge sowie analoge Messmöglichkeiten betrafen, habe ich mich dazu entschlossen, ein Set von kleinen Platinen zu entwickeln, dass es ermöglicht mit maximal 4 Ports zusätzliche Funktionen zu schaffen.

Eine Liste von Features:

  • die Ansteuerung erfolgt über Software SPI
  • freie Portbelegung
  • Entwicklungsumgebung AVR Studio 4

Hardware

Die Hardware besteht aus mehreren kleine Platinen in der Größenordnung 60 x 40 mm. Auf den Platinen befinden sich alle notwendigen Bauteile. Die Platinen sind so aufgebaut, dass sie kaskadiert werden können.

Porterweiterung über 74HC595 (Ausgang)

Platinengröße: 70 × 35 mm

Diese Platine besteht aus zwei 74HC595 die kaskadiert 16 digitale Ausgänge zur Verfügung stellt. Die Gesamtlast für einen Baustein beträgt ca. 70mA.

Die Platine wurde auf Grund eins Tipps von Peter Dannegger (PeDa) zusätzlich mit einem über den Mikrocontroller steuerbaren /OE versehen. Durch den Pullup-Widerstand am /OE befindet sich der 74HC595 nach eine Reset in einem definierten Zustand.

Stecker JP1

Mit JP1 kann /OE über den Pullup-Widerstand auf High gezogen und damit das 74HC595 in den Tristate-Modus versetzt werden. In diesem Fall muss /OE durch den Mikrocontroller bei der Initialisierung auf low gesetzt werden.

Alternativ kann /OE direkt auf GND gelegt werden. In diesem Fall braucht PIN 3 von JP2 nicht beschaltet zu werden.

Brücke Funktion
PIN 1 / 2 /OE auf GND
PIN 2 / 3 /OE über Pullup

Stecker JP2

Über JP2 erfolgt die Verbindung zum Mikrocontroller oder zu einer weiteren Porterweiterung.

Pinbelegung Funktion
PIN 1 CLK
PIN 2 RCLK
PIN 3 /OE
PIN 4 SERIN
PIN 5 SEROUT

Soll eine weitere Porterweiterung kaskadiert werden, ist darauf zu achten, dass PIN 1 und PIN 2 direkt mit den entsprechenden Anschlüssen der folgenden Platine verbunden werden müssen. Für PIN 3 falls /OE über den Pullup-Widerstand angeschlossen ist gilt das selbe.

PIN 4 wird wenn es sich um die erste Platine in der Kaskade handelt mit dem entsprechenden PORT des Mikrocontrollers verbunden.

PIN 5 wird innerhalb einer Kaskade immer mit PIN 4 der nächsten folgenden Porterweiterung verbunden.

Stecker JP3

Pinbelegung Funktion
PIN 1 Vcc
PIN 2 GND

Porterweiterung über 74HC595 (LCD)

Diese Platine besteht aus einem 74HC595 über das ein HD44780 kompatibles LCD angesteuert werden kann.

Platinengröße: 60 × 35 mm

Bestückungshinweis

Der Trimmer sollte idealerweise von der Lötseite bestückt werden, damit der Kontrast jederzeit geregelt werden kann.

Stecker JP1

Mit JP1 kann /OE über den Pullup-Widerstand auf High gezogen und damit das 74HC595 in den Tristate-Modus versetzt werden. In diesem Fall muss /OE durch den Mikrocontroller bei der Initialisierung auf low gesetzt werden.

Alternativ kann /OE direkt auf GND gelegt werden. In diesem Fall braucht PIN 3 von JP2 nicht beschaltet werden.

Brücke Funktion
PIN 1 / 2 /OE auf GND
PIN 2 / 3 /OE über Pullup

Stecker JP2

Über JP2 erfolgt die Verbindung zum Mikrocontroller oder zu einer weiteren Porterweiterung.

Pinbelegung Funktion
PIN 1 CLK
PIN 2 RCLK
PIN 3 /OE
PIN 4 SERIN
PIN 5 SEROUT

Solle eine weitere Porterweiterung kaskadiert werden, ist darauf zu achten, dass PIN 1 und PIN 2 direkt mit den entsprechenden Anschlüssen der folgenden Platine verbunden werden müssen. Für PIN 3 falls /OE über den Pullup-Widerstand angeschlossen ist gilt das selbe.

PIN 4 wird wenn es sich um die erste Platine in der Kaskade handelt mit dem entsprechenden PORT des Mikrocontrollers verbunden.

PIN 5 wird innerhalb einer Kaskade immer mit PIN 4 der nächsten folgenden Porterweiterung verbunden.

Stecker JP3

Pinbelegung Funktion
PIN 1 Vcc
PIN 2 GND

Funktionen

Über den Trimmer kann der Kontrast des Displays eingestellt werden. Falls vorhanden, kann die Hintergrundbeleuchtung des Displays über den Mikrocontroller ein und ausgeschaltet werden.

Porterweiterung über 74HC589 (Eingang)

in Planung

Porterweiterung ADC

in Planung

Porterweiterung DAC

in Planung

Software

Porterweiterung über 74HC595 (Ausgang)

Datei com74hc595.h

#ifndef _COM74HC595_H_
#define _COM74HC595_H_

// Anzahl der über Software-SPI anzusteuernde 74HC595 Bausteine
#define COM74HC595_SIZE 1

// Anzahl der Bits über alle Bausteine
#define COM74HC595_BYTES COM74HC595_SIZE * 8

// PORT am Mikrokontroller über den der Software SPI erfolgen soll
#define PORT_COM74HC595         PORTB
#define PORT_SER 		PB0		// 74HC595 PIN 14
#define PORT_SCK 		PB1		// 74HC595 PIN 11
#define PORT_RCK 		PB2		// 74HC595 PIN 12
#define PORT_OE 		PB3		// 74HC595 PIN 13

#define DDR_COM74HC595          DDRB
#define DDR_SER 		DDB0	        // 74HC595 PIN 14
#define DDR_SCK 		DDB1	        // 74HC595 PIN 11
#define DDR_RCK 		DDB2	        // 74HC595 PIN 12
#define DDR_OE 			DDB3	        // 74HC595 PIN 13

/*
Falls eine Steuerung über /OE PIN 13 des 74HC595 gewünscht ist,
muss PIN 13 per Pullup Widerstand gesetzt werden, dass sorgt
dafür, dass der 74HC595 nach einem Reset in einem definierten
Zustand gesetzt werden kann.
Der 74HC595 wird in der Initialisierungsroutine mit 0x00 initialisiert.
Dadurch, dass /OE über den Pullup-Widerstand auf HIGH gezogen wurde,
befindet sich der 74HC595 im Tristate-Modus. Wird jetzt /OE auf LOW 
gezogen, steht der gesetzte Zustand an den Ports an.
*/
#define WITH_OE

// globales Array zur Speicherung der Bitmuster
extern unsigned char com74hc595[];

// Initialisierung der Ports im Mikrocontroller
extern void com74hc595_init(void);

// Ausgabe der Bitmuster an die 74HC595
extern void com74hc595_out(void);

// setzen eines einzelnen Bits innerhalb des Arrays
extern void com74hc595_setBit( unsigned char BitNumber );

// zurücksetzen eines einzelnen Bits innerhalb des Arrays
extern void com74hc595_unsetBit( unsigned char BitNumber );

// setzen eines ganzen Ports
extern void com74hc595_setPort( unsigned char Port, unsigned char Bits );

// zurücksetzen eines ganzen Ports
extern void com74hc595_unsetPort( unsigned char Port );

// setzt alle Bits auf logisch 1
extern void com74hc595_setall(void);

// setzt alle Bits auf logisch 0
extern void com74hc595_unsetall(void);

#endif /* _COM74HC595_H_ */

Datei (com74hc595.c)

#include <avr/io.h>
#include <stdlib.h>
#include "com74hc595.h"

// Array fuer die Daten
unsigned char com74hc595[ COM74HC595_SIZE ];

void com74hc595_setBit( unsigned char BitNumber)
{
	unsigned char Port = BitNumber >> 3;
	unsigned char Bit = BitNumber & 7;
	com74hc595[ Port ] |= (1 << ( Bit ) );
}

void com74hc595_unsetBit( unsigned char BitNumber)
{
	unsigned char Port = BitNumber >> 3;
	unsigned char Bit = BitNumber & 7;
	com74hc595[ Port ] &= ~(1 << ( Bit ) );
}

void Com74hc595_setall(void)
{
	for ( int i = 0; i < COM74HC595_BYTES; i++ )
	{
		com74hc595_setBit( i );
	}
}

void com74hc595_unsetall(void)
{
	for ( int i = 0; i < COM74HC595_BYTES; i++ )
	{
		com74hc595_unsetBit( i );
	}
}

void com74hc595_setPort( unsigned char Port, unsigned char Bits )
{
	com74hc595[ Port ] = Bits;
}

void com74hc595_unsetPort( unsigned char Port )
{
	com74hc595[ Port ] = 0x00;
}


void com74hc595_init()
{
        /* Verwendete Ports auf OUT */
	DDR_com74hc595 |= ( 1 << DDR_SER);
	DDR_com74hc595 |= ( 1 << DDR_SCK);
	DDR_com74hc595 |= ( 1 << DDR_RCK);

#ifdef WITH_OE
	DDR_com74hc595 |= ( 1 << DDR_OE);
#endif

        /* SER auf definierten Level LOW */
	PORT_com74hc595 &= ~(1<<PORT_SER);



        /* SCR und RCK auf definierten Level HIGH */
	PORT_com74hc595 |= (1<<PORT_SCK);
	PORT_com74hc595 |= (1<<PORT_RCK);

#ifdef WITH_OE
	PORT_com74hc595 |= (1<<PORT_OE);
#endif

	com74hc595_unsetall();
	com74hc595_out();     

#ifdef WITH_OE
	PORT_com74hc595 &= ~(1<<PORT_OE);
#endif
}

void com74hc595_out()
{
    unsigned char anz = COM74HC595_SIZE;
    unsigned char* serp = com74hc595 + COM74HC595_SIZE;

    do
    {
        unsigned char bits;
        unsigned char data = *--serp;

        /* 8 Bits pro Byte rausschieben */
        for (bits = 8; bits > 0; bits--)
        {
	    PORT_COM74HC595 &= ~(1<<PORT_SER);
            if (data & 0x80)
            {
		PORT_COM74HC595 |= (1<<PORT_SER);
            };

            data <<= 1;
            /* Strobe an SCK schiebt Daten im Gaensemarsch */
            /* um 1 Position weiter durch alle Schieberegister */
	    PORT_COM74HC595 &= ~(1<<PORT_SCK);
	    PORT_COM74HC595 |= (1<<PORT_SCK);
        }
    }
    while (--anz > 0);

    /* Strobe an RCK bringt die Daten von den Schieberegistern in die Latches */
    PORT_COM74HC595 &= ~(1<<PORT_RCK);
    PORT_COM74HC595 |= (1<<PORT_RCK);
}

Datei (main.c)

Einfaches Lauflicht über alle Ports

#include <avr/io.h>
#define F_CPU 3686400
#include <util/delay.h>
#include "com74hc595.h"

int main(void)
{
    com74hc595_init();
 
    while(1)
    {
        for ( int i = 0; i < com74hc595_BYTES; i++ )
	{
	    com74hc595_setBit( i );
	    com74hc595_out();
            _delay_ms( 2000 );

	    com74hc595_unsetBit( i );
	    com74hc595_out();
            _delay_ms( 2000 );
	}
    }
}

Porterweiterung über 74HC595 (LCD)

LCD - Befehlssatz

Da ich in dieser Bibliothek und auf der Platine den PIN R/W des LCD-Bus auf GND gelegt habe, spielt er hier keine Rolle. Er wird deshalb auch nicht betrachtet.

Bevor ein Kommando an das LCD übergeben werden kann, muss sichergestellt sein, dass RS auf logisch 0 steht. Nur dann interpretiert das LCD das folgende Byte als Kommando.

Legende:

  • 1 = high-Pegel
  • 0 = low-Pegel
  • x = beliebiger Pegel

Display löschen bzw. zurücksetzen

Der Displayinhalt wird gelöscht und der Cursor auf die erste Position in der ersten Zeile gesetzt.

RS D7 D6 D5 D4 D3 D2 D1 D0
0 0 0 0 0 0 0 0 1

Cursor auf Startposition setzen

Der Cursor wird auf die Startposition gesetzt. Falls der Displayinhalt geshiftet wurde, wird auch der Shift zurückgesetzt.

RS D7 D6 D5 D4 D3 D2 D1 D0
0 0 0 0 0 0 0 1 x

Cursor-Richtung und Display-Shift

Dieser Befehl legt die Bewegungsrichtung des Cursors und den Display-Shift fest. Shift bedeutet, dass der gesamte Inhalt des Displays um eine Position verschoben wird.

  • C = 0: Bewegung nach links
  • C = 1: Bewegung nach rechts
  • S = 0: kein Shift
  • S = 1: Display-Inhalt wird geshiftet
RS D7 D6 D5 D4 D3 D2 D1 D0
0 0 0 0 0 0 1 C S

Display-Zustand

Mit diesem Befehl kann das Display ein- oder ausgeschaltet, der Cursor angezeigt und der Cursor blinkend dargestellt werden.

  • P = 0: Display aus
  • P = 1: Display an
  • C = 0: Cursor aus
  • C = 1: Cursor an
  • B = 0: ständig sichtbarer Cursor
  • B = 1: blinkender Cursor
RS D7 D6 D5 D4 D3 D2 D1 D0
0 0 0 0 0 1 P C B

Cursor-Funktion

Mit diesem Befehl wird festgelegt, ob beim Schreiben eines Zeichens der Cursor bewegt werden soll, oder ob der Display-Inhalt geshiftet werden soll und, in welche Richtung geshiftet werden soll

  • M = 0: Cursor bewegen
  • M = 1: Display shiften
  • S = 0: nach links shiften
  • S = 1: nach rechts shiften
RS D7 D6 D5 D4 D3 D2 D1 D0
0 0 0 0 1 M S x x

Display-Einstellungen

Es kann festgelegt werden, ob die Kommunikation mit dem LCD im 4 Bit oder 8 Bit Modus erfolgen soll.

  • B = 0: 4-Bit-Bus
  • B = 1: 8-Bit-Bus
  • N = 0: 1 Zeile
  • N = 1: 2 Zeilen
  • F = 0: 5 × 7 Punkte
  • F = 1: 5 × 10 Punkte
RS D7 D6 D5 D4 D3 D2 D1 D0
0 0 0 1 B N F x x

Adresse im Zeichensatztabelle setzen

Mit diesem Befehl, kann ein eigenes Zeichen in die Zeichensatztabelle des LCD-Controllers eingetragen werden.

RS D7 D6 D5 D4 D3 D2 D1 D0
0 0 1 A5 A4 A3 A2 A1 A0

Adresse im Datenspeicher setzen

Es wird festgelegt, dass beim Schreiben in das Datenregister mit dem nächsten Befehl an der angegebenen Adresse in den Speicher der geschrieben wird, in dem der Display-Inhalt abgelegt ist.

RS D7 D6 D5 D4 D3 D2 D1 D0
0 1 A6 A5 A4 A3 A2 A1 A0

Speicher beschreiben

Die anliegenden Daten werden in den zuletzt ausgewählten Speicher geschrieben.

RS D7 D6 D5 D4 D3 D2 D1 D0
1 D7 D6 D5 D4 D3 D2 D1 D0

Datei com74hc595_lcd.h

Um mit diesen Routinen arbeiten zu können, ist es notwendig, die Bibliothek Porterweiterung über 74HC595 (Ausgang) funktionsfähig vorliegen zu haben.

Achtung: Einige Routinen sind derzeit nur als Prototypen deklariert. Stand: 25.05.2008

// gibt die Daten über die Standardfunktionen an das LCD weiter
extern void com74hc595_lcd_nibble( unsigned char d );

// sendet ein Byte in zwei Nibble
extern void com74hc595_lcd_Byte( unsigned char d );

// sendet ein Kommando an das LCD
extern void com74hc595_lcd_command(unsigned char d);

// erzeugt den Enable-Puls
extern void com74hc595_lcd_enable(void);

// übergibt ein einzelnes Zeichen an das LCD
extern void com74hc595_lcd_data(unsigned char d);

// übergibt eine Zeichenkette an das LCD
extern void com74hc595_lcd_string(char *data);

// Initialisierung des LCD
extern void com74hc595_lcd_init(void);


// Das LCD wird gelöscht
extern void com74hc595_lcd_clear(void);

// Der Cursor wird auf Position 0,0 gesetzt
extern void com74hc595_lcd_home(void);

// Der Cursor wird auf eine konkrete Position gesetzt
extern void com74hc595_set_cursor(uint8_t x, uint8_t y);

// Hintergrundbeleuchtung einschalten
extern void com74hc595_lcd_light_on(void);

// Hintergrundbeleuchtung ausschalten
extern void com74hc595_lcd_light_off(void);

// LCD einschalten
extern void com74hc595_lcd_on(void);

// LCD ausschalten
extern void com74hc595_lcd_off(void);

// LCD Cursor einschalten
extern void com74hc595_cursor_on(void);

// LCD Cursor ausschalten
extern void com74hc595_cursor_off(void);

// LCD Cursor blinken einschalten
extern void com74hc595_cursor_flash_on(void);

// LCD Cursor blinken ausschalten
extern void com74hc595_cursor_flash_off(void);

#ifndef F_CPU
#define F_CPU	3686400
#endif
 
#ifndef _LCD_H_
#define _LCD_H_

// LCD Befehle
 
#define CLEAR_DISPLAY 0x01
#define CURSOR_HOME   0x02
#define LCD_ON        0x0C
#define CURSOR_ON     0x0A
#define CURSOR_FLASH  0x09

#define ON  0x01
#define OFF 0x00
 
// Pinbelegung für das LCD, an verwendete Pins anpassen
 
#define LCD_PORT	0
#define LCD_B4		0	// LCD PIN 4 -> 74HC595 PIN 15
#define LCD_B5		1	// LCD PIN 5 -> 74HC595 PIN 1
#define LCD_B6		2	// LCD PIN 6 -> 74HC595 PIN 2
#define LCD_B7		3	// LCD PIN 7 -> 74HC595 PIN 3
#define LCD_RS		4  	// LCD PIN 4 -> 74HC595 PIN 4
#define LCD_EN          5	// LCD PIN 6 -> 74HC595 PIN 5
#define LCD_LIGHT	6       //           -> 74HC595 PIN 6   
#define LCD_RW      	        // LCD PIN 5 -> auf GND gelegt

extern unsigned char BackLightState;
extern unsigned char LCDLightState;

#endif /* _LCD_H_ */

Datei com74hc595_lcd.c

#include <avr/io.h>
#include "com74hc595.h"
#include "com74hc595_lcd.h"
#define F_CPU 3686400
#include <util/delay.h>
 
unsigned char BackLightState = OFF;

void com74hc595_lcd_data( unsigned char d )
{
	com74hc595_setBit( LCD_RS );	
	com74hc595_lcd_Byte( d );
}
 
void com74hc595_lcd_nibble( unsigned char d )
{
	com74hc595_unsetBit( LCD_B4 );
	com74hc595_unsetBit( LCD_B5 );
	com74hc595_unsetBit( LCD_B6 );
	com74hc595_unsetBit( LCD_B7 );
	
	if ( d & 1<<4 ) com74hc595_setBit( LCD_B4 );
	if ( d & 1<<5 ) com74hc595_setBit( LCD_B5 );
	if ( d & 1<<6 ) com74hc595_setBit( LCD_B6 );
	if ( d & 1<<7 ) com74hc595_setBit( LCD_B7 );

	if ( BackLightState == ON ) com74hc595_unsetBit( LCD_LIGHT );
	if ( BackLightState == OFF ) com74hc595_setBit( LCD_LIGHT );

	com74hc595_out();

   	com74hc595_lcd_enable();
}

void com74hc595_lcd_Byte( unsigned char d )
{
 	com74hc595_lcd_nibble( d );
	com74hc595_lcd_nibble( d<<4 );
  	_delay_us( 45 );
}
 
void com74hc595_lcd_command( unsigned char d )
{
	com74hc595_unsetBit( LCD_RS );	
  	com74hc595_lcd_Byte( d );
  	switch( d )
	{
    	    case 1:
    	    case 2:
    	    case 3: _delay_ms( 2 );
  	}
}

void com74hc595_lcd_enable(void)
{
	com74hc595_setBit( LCD_EN );
	com74hc595_out();
    _delay_us(20);                  
	com74hc595_unsetBit( LCD_EN );
	com74hc595_out();
}
 
void com74hc595_lcd_init(void)
{
	// Hintergrundbeleuchtung wird abgeschaltet
	com74hc595_lcd_light_off();

	// warte, damit sich der Kontroller des LCD initialisieren kann
	_delay_ms( 15 );

   	// muss 3mal hintereinander gesendet werden zur Initialisierung
   	com74hc595_lcd_nibble(0x30);
   	_delay_ms(5);
   	com74hc595_lcd_nibble(0x30);
   	_delay_us(100);
   	com74hc595_lcd_nibble(0x30);
   	_delay_us(100);
 
   	// 4 bit mode
	com74hc595_lcd_nibble(0x20);	
  	_delay_us( 100 );			    // wait >100æs


   	// 4Bit / 2 Zeilen / 5x7
   	com74hc595_lcd_command( 0x28 );

	// Display aus
   	com74hc595_lcd_command( 0x08 ); 

	// Display löschen
   	com74hc595_lcd_clear();

   	// inkrement / kein Scrollen
   	com74hc595_lcd_command( 0x06 );

  	// Display ein / Cursor aus / kein Blinken
   	com74hc595_lcd_command( 0x0C ); 
}
 
void com74hc595_lcd_light_on(void)
{
	com74hc595_setBit( LCD_LIGHT );
	com74hc595_out();
	BackLightState = ON;
}

void com74hc595_lcd_light_off(void)
{
	com74hc595_unsetBit( LCD_LIGHT );
	com74hc595_out();
	BackLightState = OFF;
}

void com74hc595_lcd_clear(void)
{
        com74hc595_lcd_command( CLEAR_DISPLAY );
        _delay_ms(5);
}
 
void com74hc595_lcd_home(void)
{
        com74hc595_lcd_command( CURSOR_HOME );
        _delay_ms(5);
}
 
void com74hc595_set_cursor(uint8_t x, uint8_t y)
{
        uint8_t tmp = 0x00;
 
        switch (y) 
        {
            case 1: tmp=0x80+0x00+x; break;    // 1. Zeile
            case 2: tmp=0x80+0x40+x; break;    // 2. Zeile
            case 3: tmp=0x80+0x10+x; break;    // 3. Zeile
            case 4: tmp=0x80+0x50+x; break;    // 4. Zeile
        }
        com74hc595_lcd_command(tmp);
}
 
void com74hc595_lcd_string(char *data)
{
        while(*data) 
	{
            com74hc595_lcd_data(*data);
            data++;
        }
}

Datei main.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include "com74hc595.h"
#include "com74hc595_LCD.h"

int main(void)
{
	com74hc595_init();
    com74hc595_lcd_init();

    com74hc595_lcd_light_on();

    com74hc595_lcd_data('T');
    com74hc595_lcd_data('e');
    com74hc595_lcd_data('s');
    com74hc595_lcd_data('t');
    com74hc595_set_cursor(0,2);
 
    com74hc595_lcd_string("Hello World!");
 
    while(1)
    {
    }
 
    return 0;
}

Porterweiterung über 74HC589 (Eingang)

Porterweiterung ADC

Porterweiterung DAC

Downloads

Die Downloads der Software enthalten lediglich die Bibliotheksfunktionen. Die entsprechenden Demos werden hier veröffentlicht und können durch Copy und Paste in die jeweilige main.c übernommen werde.

Das Platinenlayout wurde mit SprintLayout erstellt und im PDF-Format gespeichert. Alle Platinen wurden einseitig layoutet. Dadurch müssen Brücken auf der Platine gelegt werden.

Ich habe lange darüber nachgedacht, ob dies Sinn macht. Aber, wenn eine möglichst breite Masse an Personen diese Platinen in eigener Regie erstellen können soll, ist einseitig die beste Lösung.

Um das im PDF hinterlegte Layout zu drucken, ist darauf zu achten, dass alle Skalierungen im PDF-Reader ausgeschaltet sind (Seitenanpassung: keine). Wird diese Einstellung nicht gewählt, wird das Layout um die entsprechende angegebene Skalierung verkleinert!

Die private Nutzung der Sourcecode und der Platinenlayouts ist ausdrücklich gestattet. Eine gewerbliche Nutzung bitte ich mit mir abzustimmen.

Porterweiterung über 74HC595 (Ausgang)

Porterweiterung über 74HC595 (LCD)

Porterweiterung über 74HC589 (Eingang)

  • Sourcecode:
  • Platinenlayout:

Porterweiterung ADC

  • Sourcecode:
  • Platinenlayout:

Porterweiterung DAC

  • Sourcecode:
  • Platinenlayout:

Siehe auch