Inhalt
Material
- Zwei 74HC595N
- Zwei 7-Segment-Anzeigen
- Diverse Kabel
- 16 Widerstände mit 330 Ohm
- Steckbrett
74HC595N |
Die Anschlüsse VCC und GNC verstehen sich von selbst. Die Q0:Q7 sind die 8 Ausgänge. Der Register wird durch einen seriellen Datenstrom an DS beschrieben. Mit einem kurzen Puls an SHC wird eine Shift-Operation durchgeführt. Der DS eines zweiten Bausteins kann an den seriellen Ausgang Q7', der den gleichen Wert wie Q7 hat, angeschlossen werden. Dadurch können längere Wörter als 8-Bit durch die Register geshiftet werden. Mit STC wird die Shiftphase beendet und die Ausgänge Q0:Q7 übernehmen die Daten, die in die Register geschrieben wurden. Der MR-Anschluss ist für ein Reset zuständig und kann direkt an 5V angeschlossen werden. Durch OE steuert man, ob die Ausgänge einen High-Pegel ausgeben oder sich stattdessen im Z-Zustand befinden. Man sollte diesen Anschluss einfach an GND anschließen.
Der gesamte Aufbau sieht dann wie folgt aus:
Gesamtaufbau |
Hier sieht man, dass vom Raspberry Pi nur drei Anschlüsse, je einen für DS, SHC und STC, gebraucht werden, um insgesamt 16 Ausgänge anzusteuern.
Programm
Es werden zum Beschreiben der Speicherbausteine nur drei Ausgänge benötigt. Diese müssen am Anfang des Programms initialisiert werden:
#define DSPIN 27 #define STCPPIN 28 #define SHCPPIN 29 void init() { pinMode(DSPIN, OUTPUT); pinMode(STCPPIN, OUTPUT); pinMode(SHCPPIN, OUTPUT); digitalWrite(DSPIN, LOW); digitalWrite(STCPPIN, LOW); digitalWrite(SHCPPIN, LOW); }
Die Konstanten DSPIN, STCPPIN und SHCPPIN sind die entsprechenden Ausgänge des Raspberry Pi, mit denen die Signale erzeugt werden sollen.
Zum Beschreiben der beiden Speicherbausteine werde ich die Daten byteweise ausgeben. Dazu definiere ich mir eine Funktion, die mir für jede Ziffer von 0 bis 9 den entsprechenden Byte zurückgibt, sodass ein Speicherbaustein die 7-Segment-Anzeige entsprechend der Abbildung unten ansteuert.
Q0 ist für den Punkt, Q7 für den Mittelstrich |
Die entsprechende Funktion sieht bei mir folgendermaßen aus:
char getSegmByte(int num) { switch(num) { case 0: return 0b01111111; case 9: return 0b11110111; case 8: return 0b11111111; case 7: return 0b00110011; case 6: return 0b11101111; case 5: return 0b11100111; case 4: return 0b11010011; case 3: return 0b10110111; case 2: return 0b10111101; case 1: return 0b00010011; default: return 0b11101101; // 'E' für Error } }
Sollten sich eure 7-Segment-Anzeigen anders ansteuern lassen oder wenn ihr andere Symbole anzeigen wollte, müsst ihr die Bits entsprechend ändern.
Als nächstes schreibe ich zwei Funktionen, mit denen ich je ein SHC oder ein STC Signal erzeugen kann:
#define STCPPIN 28 #define SHCPPIN 29 #define DELAYTIME 100 void STCP_tick() { digitalWrite(STCPPIN, HIGH); delayMicroseconds(DELAYTIME); digitalWrite(STCPPIN, LOW); delayMicroseconds(DELAYTIME); } void SHCP_tick() { digitalWrite(SHCPPIN, HIGH); delayMicroseconds(DELAYTIME); digitalWrite(SHCPPIN, LOW); delayMicroseconds(DELAYTIME); }
Damit die Signale eine gewisse Zeit aktiv bleiben, wird das Programm für ein paar Millisekunden pausiert.
Jetzt benutzen wir die Tick-Funktionen zum schreiben eines Bytes:
void writeByte(char byte) { for(int i = 0; i < 8; i++) { digitalWrite(DSPIN, ((byte & (1 << (7-i))) ? HIGH : LOW)); delayMicroseconds(DELAYTIME); SHCP_tick(); } STCP_tick(); }
Die erste Anweisung in der for-Schleife wirkt auf den ersten Blick verwirrend. Hier wird die Stelle 7-i in dem übergebenden Byte überprüft, ob sie 1 oder eine 0 ist und entsprechend ein HIGH- oder LOW-Signal auf den DSPIN geschrieben. Durch SHCP_tick wird das Signal in den Register geshiftet und nach der for-Schleife die Daten auf dem Register ausgegeben.
Der Timer soll einen Integer hoch zählen und immer die letzten beiden Ziffern ausgeben. Dazu wurde folgende Funktion geschrieben:
void writeNumber(int num, unsigned int digits) { for(unsigned int i = 0; i < digits; i++) { int digit = (i ? (num/(i*10)) : num)%10; writeByte(getSegmByte(digit)); } }
Damit das ganze System später um weitere 7-Segment-Anzeigen erweitert werden kann, bekommt die Funktion noch einen Parameter, der die Anzahl der auszugebenden Ziffern enthält. Die Ziffern werden dann in einer for-Schleife byteweise in die Register geschrieben.
Zum Schluss kommt alles in eine main-Funktion unter:
#define DELAYSECOND 1000 #define DIGITS 2 /* Rest des Programms */ int main() { if(wiringPiSetup() == -1) { return 1; } init(); int time = 0; while(1) { printf("%d\n", time); writeNumber(time++, DIGITS); delay(DELAYSECOND); } return 0; }
Damit hat man einen Timer, der im Sekundentakt hoch zählt und die letzten beiden Ziffern des aktuellen Werts auf den 7-Segment-Anzeigen ausgibt mit Hilfe von 74HC595N-Bausteinen. Durch Anpassen der DIGIT-Konstante können weniger oder mehr Ziffern ausgegeben und damit weniger oder mehr Bausteine beschrieben werden.
Ich hoffe dieses Tutorial hat euch bei der Verwendung des 74HC595N weitergeholfen oder euch seinen Nutzen näher gebracht und euch zum Kauf angeregt. Für weitere Informationen zum 74HC595N siehe:
Keine Kommentare:
Kommentar veröffentlichen
Hinweis: Nur ein Mitglied dieses Blogs kann Kommentare posten.