ATmega, 74hc595 og læsning af input

[Danni-Hansen]

Dette er iøvrigt koden jeg brugte:

//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 dataGREEN;
byte dataYELLOW;
byte dataRED;
byte dataArrayGREEN[10];
byte dataArrayYELLOW[10];
byte dataArrayRED[10];

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


  //Arduino doesn't seem to have a way to write binary straight into the code
  //so these values are in HEX.  Decimal would have been fine, too.
  dataArrayGREEN[0] = 0xFF; //11111111
  dataArrayGREEN[1] = 0x7F; //01111111
  dataArrayGREEN[2] = 0x3F; //00111111
  dataArrayGREEN[3] = 0x1F; //00011111
  dataArrayGREEN[4] = 0x0F; //00001111
  dataArrayGREEN[5] = 0x07; //00000111
  dataArrayGREEN[6] = 0x03; //00000011
  dataArrayGREEN[7] = 0x01; //00000001
  dataArrayGREEN[8] = 0x00; //00000000
  dataArrayGREEN[9] = 0x07; //00000111


  //Arduino doesn't seem to have a way to write binary straight into the code
  //so these values are in HEX.  Decimal would have been fine, too.
  dataArrayYELLOW[0] = 0xFF; //11111111
  dataArrayYELLOW[1] = 0x7F; //01111111
  dataArrayYELLOW[2] = 0x3F; //00111111
  dataArrayYELLOW[3] = 0x1F; //00011111
  dataArrayYELLOW[4] = 0x0F; //00001111
  dataArrayYELLOW[5] = 0x07; //00000111
  dataArrayYELLOW[6] = 0x03; //00000011
  dataArrayYELLOW[7] = 0x01; //00000001
  dataArrayYELLOW[8] = 0x00; //00000000
  dataArrayYELLOW[9] = 0x07; //00000111

  //Arduino doesn't seem to have a way to write binary straight into the code
  //so these values are in HEX.  Decimal would have been fine, too.
  dataArrayRED[0] = 0xFF; //11111111
  dataArrayRED[1] = 0xFE; //11111110
  dataArrayRED[2] = 0xFC; //11111100
  dataArrayRED[3] = 0xF8; //11111000
  dataArrayRED[4] = 0xF0; //11110000
  dataArrayRED[5] = 0xE0; //11100000
  dataArrayRED[6] = 0xC0; //11000000
  dataArrayRED[7] = 0x80; //10000000
  dataArrayRED[8] = 0x00; //00000000
  dataArrayRED[9] = 0xE0; //11100000

  //function that blinks all the LEDs
  //gets passed the number of blinks and the pause time
  blinkAll_2Bytes(2,500);
}

void loop() {


  for (int j = 0; j < 10; j++) {
    //load the light sequence you want from array
    dataGREEN = dataArrayGREEN[j];
    dataYELLOW = dataArrayYELLOW[j];
    dataRED = dataArrayRED[j];   
    //ground latchPin and hold low for as long as you are transmitting
    digitalWrite(latchPin, 0);
    //move 'em out
    shiftOut(dataPin, clockPin, dataGREEN);   
    shiftOut(dataPin, clockPin, dataYELLOW);
    shiftOut(dataPin, clockPin, dataRED);
    //return the latch pin high to signal chip that it
    //no longer needs to listen for information
    digitalWrite(latchPin, 1);
    delay(300);
  }
}



// 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, 255);
    shiftOut(dataPin, clockPin, 255);
    digitalWrite(latchPin, 1);
    delay(d);
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, 0);
    shiftOut(dataPin, clockPin, 0);
    digitalWrite(latchPin, 1);
    delay(d);
  }
}

[Danni-Hansen]

Nu prøvede jeg dette af på en enkelt 78hc595:

//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;

void setup() {
  //set pins to output because they are addressed in the main loop
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT); 
  pinMode(clockPin, OUTPUT);
}

void loop() {
    // write to the shift register with the correct bit set high:
    registerWrite(random(0,7), HIGH);
    delay(500);
}

// This method sends bits to the shift register:

void registerWrite(int whichPin, int whichState) {
// the bits you want to send
  byte bitsToSend = 0;

  // turn off the output so the pins don't light up
  // while you're shifting bits:
  digitalWrite(latchPin, LOW);

  // turn on the next highest bit in bitsToSend:
  bitWrite(bitsToSend, whichPin, whichState);

  // shift the bits out:
  shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);

    // turn on the output so the LEDs can light up:
  digitalWrite(latchPin, HIGH);

}

Og det gav som man nok kan forstille sig et random tændt LED.
Og det var dejligt, nu ved jeg da nogenlunde hvordan jeg skal komme videre fra arduino IDE'et

[pacman]

Hvilket må være omkrng 0.022A?

Det kommer an på din LED (hver LED type er forskellig: Spænding, Strøm, lysstyrke - og selvføligelig farve).
Hvis du har data på din LED, så kan du regne det ud. Ellers kan du bruge et amperemeter.
(Amperemetret indsættes mellem modstanden og LED'en)

Amperene der løber gennem din LED vil være de samme som amperene der løber gennem din modstand.
Hvis dine LEDs er 3V/20mA...
...Så skal der ligge 3V over din LED og 2V over din modstand:
   2V / 0.020A = 100 ohm

Hvis dine LEDs er 3V/30mA...
...Så skal der stadig ligge 3V over din LED og 2V over din modstand:
   2V / 0.030A = 66.67 ohm

Hvis dine LEDs er 3V/10mA...
   2V / 0.010A = 200 ohm

Hvis dine LEDs er 3V/22mA: 2V / 0.022A = 90.9 ohm

Som du kan se... Jo større modstand, desto lavere ampere. Hvis du har en 220 ohm modstand på, tror jeg du kan sætte omkring 6 LEDs på.
Du skal nok op på minimum 330 ohm, gerne 390 eller 470 ohm, for at have 8 stk på hver 74595.

[pacman]

Hmm, er lidt i tvivl om hvad du mener Pacman.. :-/

Mit første forsøg slog fejl, fordi der var en ting jeg havde glemt at tænke over, så jeg må lige have lidt mere tid til at give et fornuftigt eksempel.

Prøv at se min nye tråd med Modstands DAC omkring hvordan det kan gøres.