5. November 2010

Beim Eingeben eines "o" wird ein "OK" über die LED-Matrix ausgegeben, bei der Eingabe eines "n" ein "NO". Die Matrix wird über zwei 74HC595-Chips angesteuert, die mittels Serial OUT/IN miteinander verbunden sind.

//**************************************************************//
//  Name    : shiftOutCode, Predefined Dual Array Style         //
//  Author  : Carlyn Maw, Tom Igoe                              //
//  Date    : 25 Oct, 2006                                      //
//  Version : 1.0                                               //
//  Notes   : Code for using a 74HC595 Shift Register           //
//          : to count from 0 to 255                            //
//****************************************************************

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

//holders for infromation you're going to pass to shifting function
byte dataRED = B11111001;
byte dataGREEN = B10011111;
byte dataArray1[2];
byte dataArray2[2];
byte INtext = 0;

void setup() {
 //set pins to output because they are addressed in the main loop
 pinMode(latchPin, OUTPUT);
 Serial.begin(9600);

 //function that blinks all the LEDs
 //gets passed the number of blinks and the pause time
 blinkAll_2Bytes(5,100);

}

void loop() {
 if (Serial.available() > 0) {
 INtext = Serial.read();

 if (INtext == 'o') {
 Serial.println("OK");
 setOK();
 } else if (INtext == 'n') {
 Serial.println("NO");
 setNO();
 } else {
 Serial.println("--");
 }

 //ground latchPin and hold low for as long as you are transmitting
 digitalWrite(latchPin, 0);
 //move 'em out
 shiftOut(dataPin, clockPin, dataArray1[0]);
 shiftOut(dataPin, clockPin, dataArray1[1]);
 //return the latch pin high to signal chip that it
 //no longer needs to listen for information
 digitalWrite(latchPin, 1);
 delay(500);

 //ground latchPin and hold low for as long as you are transmitting
 digitalWrite(latchPin, 0);
 //move 'em out
 shiftOut(dataPin, clockPin, dataArray2[0]);
 shiftOut(dataPin, clockPin, dataArray2[1]);
 //return the latch pin high to signal chip that it
 //no longer needs to listen for information
 digitalWrite(latchPin, 1);
 delay(500);

 //ground latchPin and hold low for as long as you are transmitting
 digitalWrite(latchPin, 0);
 //move 'em out
 shiftOut(dataPin, clockPin, 0);
 shiftOut(dataPin, clockPin, 0);
 //return the latch pin high to signal chip that it
 //no longer needs to listen for information
 digitalWrite(latchPin, 1);
 delay(500);
 }
}

void setOK () {
 // "O"
 dataArray1[0] = B11111001;
 dataArray1[1] = B10011111;

 // "K"
 dataArray2[0] = B01010011;
 dataArray2[1] = B00110101;
}

void setNO () {
 // "N"
 dataArray1[0] = B10011101;
 dataArray1[1] = B10111001;

 // "O"
 dataArray2[0] = B11111001;
 dataArray2[1] = B10011111;
}

// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
 // This shifts 8 bits out MSB first,
 //on the rising edge of the clock,
 //clock idles low

 //internal function setup
 int i=0;
 int pinState;
 pinMode(myClockPin, OUTPUT);
 pinMode(myDataPin, OUTPUT);

 //clear everything out just in case to
 //prepare shift register for bit shifting
 digitalWrite(myDataPin, 0);
 digitalWrite(myClockPin, 0);

 //for each bit in the byte myDataOut�
 //NOTICE THAT WE ARE COUNTING DOWN in our for loop
 //This means that %00000001 or "1" will go through such
 //that it will be pin Q0 that lights.
 for (i=7; i>=0; i--)  {
 digitalWrite(myClockPin, 0);

 //if the value passed to myDataOut and a bitmask result
 // true then... so if we are at i=6 and our value is
 // %11010100 it would the code compares it to %01000000
 // and proceeds to set pinState to 1.
 if ( myDataOut & (1<<i) ) {
 pinState= 1;
 }
 else {
 pinState= 0;
 }

 //Sets the pin to HIGH or LOW depending on pinState
 digitalWrite(myDataPin, pinState);
 //register shifts bits on upstroke of clock pin
 digitalWrite(myClockPin, 1);
 //zero the data pin after shift to prevent bleed through
 digitalWrite(myDataPin, 0);
 }

 //stop shifting
 digitalWrite(myClockPin, 0);
}

//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
 digitalWrite(latchPin, 0);
 shiftOut(dataPin, clockPin, 0);
 shiftOut(dataPin, clockPin, 0);
 digitalWrite(latchPin, 1);
 delay(200);
 for (int x = 0; x < n; x++) {
 digitalWrite(latchPin, 0);
 shiftOut(dataPin, clockPin, B11111111);
 shiftOut(dataPin, clockPin, B11111111);
 digitalWrite(latchPin, 1);
 delay(d);
 digitalWrite(latchPin, 0);
 shiftOut(dataPin, clockPin, 0);
 shiftOut(dataPin, clockPin, 0);
 digitalWrite(latchPin, 1);
 delay(d);
 }
}