Porterweiterungen

2013-03-21T14:02:48Z

0:0:0:FFFF:194:175:222:211: /* Siehe auch */

''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) ===

[[Bild:Porterweiterung_74HC595.png|thumb|right|250px|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.

{| border="1"
|-
!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.

{| border="1"
|-
!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'''

{| border="1"
|-
!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.

[[Bild:Porterweiterung_74HC595_lcd.png|thumb|right|250px|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.

{| border="1"
|-
!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.

{| border="1"
|-
!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'''

{| border="1"
|-
!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 ====

<c>#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_ */
</c>

==== Datei (com74hc595.c) ====

<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);
}
</c>

==== Datei (main.c) ====

Einfaches Lauflicht über alle Ports

<c>
#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 );
}
}
}
</c>

=== 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.

{| border="1"
|-
!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.

{| border="1"
|-
!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

{| border="1"
|-
!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

{| border="1"
|-
!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

{| border="1"
|-
!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

{| border="1"
|-
!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.

{| border="1"
|-
!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.

{| border="1"
|-
!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.

{| border="1"
|-
!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

<c>
// 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_ */
</c>

==== Datei com74hc595_lcd.c ====

<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++;
}
}
</c>

==== Datei main.c ====

<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;
}
</c>

=== 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) ===

* Sourcecode: [[Media:Porterweiterung_74HC595.zip|Porterweiterung_74HC595.zip]]
* Platinenlayout: [[Media:Porterweiterung_74HC595.pdf|Porterweiterung_74HC595.pdf]]

=== Porterweiterung über 74HC595 (LCD) ===

* Sourcecode: [[Media:Porterweiterung_74HC595_lcd.zip|Porterweiterung_74HC595_lcd.zip]]
* Platinenlayout: [[Media:Porterweiterung_74HC595_lcd.pdf|Porterweiterung_74HC595_lcd.pdf]]

=== Porterweiterung über 74HC589 (Eingang) ===
* Sourcecode:
* Platinenlayout:

=== Porterweiterung ADC ===
* Sourcecode:
* Platinenlayout:
=== Porterweiterung DAC ===
* Sourcecode:
* Platinenlayout:

== Siehe auch ==
* Diskussion zu diesem Projekt: http://www.mikrocontroller.net/topic/100684

* Allgemeines zu Porterweiterung : [[Erweiterung von digitalen IO-Ports]]

[[Kategorie:AVR-Projekte]]
[[Category:Portexpander]]

Erweiterung von digitalen IO-Ports

2013-03-21T14:00:48Z

0:0:0:FFFF:194:175:222:211: /* Links */

Für einfache Steueraufgaben werden oft Referenzspannungen benötigt, die man nur relativ langsam oder gar nicht ändern muss. Dafür sollen gfs. keine Chips und weitere Pins am Controller verwendet werden. Um die Zahl der Ports zu erweitern, können folgende Schaltungen eingesetzt werden:

== Schieberegister ==

[[Datei:Erweiterung digitaler ausgaenge 1.png|thumb|right|320px|Multiplex-PWM als Port-Erweiterung für FPGAs]]
Die nebenstehende Schaltung besteht aus einem Schieberegister, das mit einem schnellen Taktsignal getrieben wird. Es erzeugt 4 unabhängige digitale Signale, die sich infolge der Dämpfungsglieder nicht schnell mitändern können. Auf diese Weise werden multiplexte PWM-Ausgänge geschaffen, die mit einem 1/4-tel der Taktfrequenz arbeiten. Die Fehlschaltungen, die beim Durchtakten eines neuen Schaltmusters entstehen, können bei der PWM-Generation im FPGA berücksichtigt werden. Um sie als echte digitale Ausgänge nutzen zu können, kann ein Buffer nachgeschaltet werden, der auch als Leistungstreiber agieren kann.
{{Absatz}}

== Schieberegister mit Latch==

[[Datei:Erweiterung digitaler ausgaenge 2.png|thumb|right|320px|Stabile Zusatzports mit Latch]]
Ist ein reiner digitaler Ausgang benötigt, der nicht zittern darf, sollte ein Latch eingesetzt werden, das dann mit nur einem der künstlich erzeugten Bits getaktet werden muss. Dazu muessen doppelt soviele Befehlssequenzen ausgegeben werden, wobei das Latch-enable eine 0/1 sehen muss. Es sollte ein Latch mit Schmitt-Trigger-Eingängen verwendet werden.

{Absatz}

== Links ==
* Artikel zur PWM-Glättung: [[Glättungsfilter für 1-Bit DA-Wandlung|1-Bit Digital-Analog-Wandlung]]

* Porterweiterung mit SPI : [[Porterweiterung mit SPI]]

* Porterweiterung mit Standard-Chips : [[Porterweiterungen]]

[[Kategorie:Portexpander]]

Mikrocontroller.net - Benutzerbeiträge [de]

Porterweiterungen

Erweiterung von digitalen IO-Ports