shiftin

ciao
sto facendo prove con la funzione shiftin e il cd4021bp

//**************************************************************//
//  Name    : shiftIn Example 1.1                              //
//  Author  : Carlyn Maw                                        //
//  Date    : 25 Jan, 2007                                      //
//  Version : 1.0                                               //
//  Notes   : Code for using a CD4021B Shift Register    	//
//          :                                                   //
//****************************************************************

//define where your pins are
int latchPin = 8;
int dataPin = 9;
int clockPin = 7;

//Define variables to hold the data 
//for shift register.
//starting with a non-zero numbers can help
//troubleshoot
byte switchVar1 = 72;  //01001000

void setup() {
  //start serial
  Serial.begin(9600);

  //define pin modes
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT); 
  pinMode(dataPin, INPUT);

}

void loop() {

  //Pulse the latch pin:
  //set it to 1 to collect parallel data
  digitalWrite(latchPin,1);
  //set it to 1 to collect parallel data, wait
  delayMicroseconds(20);
  //set it to 0 to transmit data serially  
  digitalWrite(latchPin,0);

  //while the shift register is in serial mode
  //collect each shift register into a byte
  //the register attached to the chip comes in first 
  switchVar1 = shiftIn(dataPin, clockPin);

  //Print out the results.
  //leading 0's at the top of the byte 
  //(7, 6, 5, etc) will be dropped before 
  //the first pin that has a high input
  //reading  
  Serial.println(switchVar1, BIN);

//white space
Serial.println("-------------------");
//delay so all these print satements can keep up. 
delay(500);

}

//------------------------------------------------end main loop

////// ----------------------------------------shiftIn function
///// just needs the location of the data pin and the clock pin
///// it returns a byte with each bit in the byte corresponding
///// to a pin on the shift register. leftBit 7 = Pin 7 / Bit 0= Pin 0

byte shiftIn(int myDataPin, int myClockPin) { 
  int i;
  int temp = 0;
  int pinState;
  byte myDataIn = 0;

  pinMode(myClockPin, OUTPUT);
  pinMode(myDataPin, INPUT);
//we will be holding the clock pin high 8 times (0,..,7) at the
//end of each time through the for loop

//at the begining of each loop when we set the clock low, it will
//be doing the necessary low to high drop to cause the shift
//register's DataPin to change state based on the value
//of the next bit in its serial information flow.
//The register transmits the information about the pins from pin 7 to pin 0
//so that is why our function counts down
  for (i=7; i>=0; i--)
  {
    digitalWrite(myClockPin, 0);
    delayMicroseconds(0.2);
    temp = digitalRead(myDataPin);
    if (temp) {
      pinState = 1;
      //set the bit to 0 no matter what
      myDataIn = myDataIn | (1 << i);
    }
    else {
      //turn it off -- only necessary for debuging
     //print statement since myDataIn starts as 0
      pinState = 0;
    }

    //Debuging print statements
    //Serial.print(pinState);
    //Serial.print("     ");
    //Serial.println (dataIn, BIN);

    digitalWrite(myClockPin, 1);

  }
  //debuging print statements whitespace
  //Serial.println();
  //Serial.println(myDataIn, BIN);
  return myDataIn;
}

ottengo questo risultato anomalo con i contatti tutti chiusi:
11111111
aprendone poi uno alla volta:
11111110
11111101
11111011
11110111
11101111
11011111
10111111
aprendo il contatto del pin 8 invece accade questo
1111111
la funzione shiftin prevede anche i termini MSBFIRST O LSBFIRST
ho provato ad inserirle ma ottengo degli errori durante la verifica, qualcuno ha fatto qualche esperienza?

grazie

il serial.print omette i zero iniziali.
Ciao Uwe

buongiorno
grazie uwe,
ma in quale modo si può fare la visualizzazione, ed inoltre MSBFIRST E LSBFIRST, come si usano?

Con MSBFIRST e LSBFIRST definisci in che sequenza i bit letti vengono interpretati come Byte.
MSB (Most Significant Byte) vuol dire che il Bit che corrispinde al bit piú alto viene per primo.
LSB il contrario

ma in quale modo si può fare la visualizzazione

Non capisco cosa vuoi dire. Ti spiegi per favore meglio?
Ciao Uwe

grazie uwe
con LSB e MSB la compilazione mi d errori
per la visualizzazione volevo solo capire come vedere lo 0 omesso dalla serial.println

ciao
stefano

Una cosa che funziona ma che non é la soluzione piú pulita:
if (myDataIn < 128) Serial.print(“0”);
Serial.println(myDataIn, BIN);

http://arduino.cc/en/Reference/ShiftIn
dervi scrivere MSBFIRST oppure LSBFIRST

ciao Uwe

ciao
mi sorge un dubbio leggendo il programma la funzione IF non deve verificare una condizione io leggo solo IF (temp) {…, non dovrei trovare operatori tipo < = > ecc ho riletto il reference per la funzione IF ma non trovo esempi simili

grazie
stefano

L'istruzione If serve a verificare una condizione.
Quando non viene specificato nessun confronto, significa implicitamente che viene testata la variabile con TRUE, ossia se tale variabile ha un valore riconducibile a TRUE.

Il test è:

if (temp) {

Il compilatore lo traduce in if (temp == TRUE) {

TRUE è un valore booleano che in realtà è un qualunque valore che sia vero, ossia che "esista". Per capire TRUE è un alias per 1, e FALSE è un alias per 0.
Affinché temp sia vera, deve avere un valore che "esista", vale a dire che sia almeno 1.
Quindi if (temp) significa: se (temp ha un valore), cioè se temp è diverso da 0.

Spesso vengono usate tali forme stringate ma io personalmente sono della "vecchia scuola", e preferisco sempre (per aiutare la leggibilità del codice di altri utenti) specificare esplicitamente il confronto: if (temp > 0)

ok capito
grazie

ps anche io sono della vecchia scuola

buongiorno
riprendo questo vecchio argomento per avere suggerimenti, sto utilizzando 2 shift register per leggere lo stato di 10 interruttori a levetta, per pilotare 10 led mediante 10 uscite digitali di arduino, il suggerimento cercato riguarda come mettere lo stato 0 o 1 dei due byte come elementi di un vettore/i che letti ad intervalli di tempo variabili, in un loop, mi comandi l'accensione o meno del corrispondente led

grazie
stefano

cosa intendi come vettore?
Ciao Uwe

ciao
intendo un array 1 riga 8/16 colonne o viceversa 8/16 righe 1 colonna

ciao
questo comando puo' risolvere il problema?

http://arduino.cc/en/Reference/BitRead

Però il fatto di non conoscere lo schema non aiuta.
Se ho capito bene, tu leggi i pulsantini con un paio di parallel-to-serial register, quindi usi ShiftIn per questo motivo.
Perché allora non usare un paio di serial-to-parallel register e far uscire da 3 pin tramite ShiftOut le impostazioni per i 10 led?

Semplificheresti moltissimo e non dovresti far altro che trasmettere i 2 byte letti con ShiftIn direttamente in uscita senza manipolazioni: se leggi "1" (interruttore attivato) allora scrivi "1" (LED acceso).

Esistono anche dei LED driver che non necessitano neanche di resistenze sulle linee perché forniscono la tensione corretta per pilotare direttamente i LED (non mi ricordo la sigla).

buongiorno
per lo schema vedo di provvedere, si conosco lo shiftout ma quello che voglio e' variare il tempo che intercorre fra l'accessione di un led e il successivo mediante un potenziometro tra l'inizio di un loop e l'altro, con shiftout riesco a cambiare il tempo tra un bit e l'altro in trasmissione?

ciao
riprendo questo post per avere una spiegazione di questo comportamento:

//codice sviluppato partendo dal lavoro dei sottoelencati autori
// Author : Carlyn Maw, Tom Igoe
// Notes : Code for using a CD4021B Shift Register
// Notes : Code for using a 74hc595 Shift Register

/*il seguente codice utilizza le funzioni shifout
e le funzioni shiftin, viene eseguito il controllo dello stato
dei contatti su shiftin e la memorizzazione
nei registri di shiftin e riprodotti sui led dalla funzione shiftout
il led sarà in parallelo alla elettrovalvola
*/

//pin per shiftout
//Pin connected to ST_CP of 74HC595
int latchPinOUT = 11;
//Pin connected to SH_CP of 74HC595
int clockPinOUT = 12;
////Pin connected to DS of 74HC595
int dataPinOUT = 10;

//pin per shiftin
//Pin connected to P/SC of 4021
int latchPinIN = 8;
//Pin connected to Q8 of 4021
int dataPinIN = 9;
//Pin connected to CLOCK of 4021
int clockPinIN = 7;

//Define variables to hold the data
//for shift register.
//starting with a non-zero numbers can help
//troubleshoot
byte switchVar1 = 78; //01001110
byte switchVar2 = 159; //10011111

byte Var1 = 128; //01001110
byte Var2 = 159; //10011111

int n=0; //contatore
int pinsensore=2; //pin a cui collegarare il sensore induttivo
int statosensore=LOW; //stato iniziale del sensore

void setup()
{
//set pins to output so you can control the shift registers
//shiftout define pin modes
pinMode(latchPinOUT, OUTPUT);
pinMode(clockPinOUT, OUTPUT);
pinMode(dataPinOUT, OUTPUT);

//shiftin define pin modes
pinMode(latchPinIN, OUTPUT);
pinMode(clockPinIN, OUTPUT);
pinMode(dataPinIN, INPUT);

pinMode(pinsensore,INPUT);

Serial.begin(9600);
}

void loop()
{

//lettura dello stato dei pin in input
//shiftin
//Pulse the latch pin:
//set it to 1 to collect parallel data
digitalWrite(latchPinIN,1);
//set it to 1 to collect parallel data, wait
delayMicroseconds(50);
//set it to 0 to transmit data serially
digitalWrite(latchPinIN,0);

//while the shift register is in serial mode
//collect each shift register into a byte
//the register attached to the chip comes in first
switchVar1 = shiftIn(dataPinIN, clockPinIN);
switchVar2 = shiftIn(dataPinIN, clockPinIN);

//white space
// Serial.println("-------------------");
//Print out the results.
//leading 0’s at the top of the byte
//(7, 6, 5, etc) will be dropped before
//the first pin that has a high input
//reading
// Serial.println(“switchVar1_IN”);
// Serial.println(switchVar1, BIN);
// Serial.println(int(switchVar1));
// Serial.println(“switchVar2_IN”);
// Serial.println(switchVar2, BIN);
// Serial.println(int(switchVar2));

/*
//sezione per shiftout
//visualizza lo stato complessivo degli switch accendendo i led crrispondenti
digitalWrite(latchPinOUT, LOW); //Pull latch LOW to start sending data
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, switchVar2); //Send the data byte 2
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, switchVar1); //Send the data byte 1
digitalWrite(latchPinOUT, HIGH); //Pull latch HIGH to stop sending data

//delay so all these print satements can keep up.
delay(500);

//sezione per shiftout spegne tutti i led
Var1=0;
Var2=0;
digitalWrite(latchPinOUT, LOW); //Pull latch LOW to start sending data
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2); //Send the data byte 2
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1); //Send the data byte 1
digitalWrite(latchPinOUT, HIGH); //Pull latch HIGH to stop sending data
delay(500);
*/
//questa sezione è il cuore e scopo del programma
//lo shiftin memorizza lo stato dei 10 sensori HIGH o LOW
//per la verifica della presenza o meno della pianta nel condotto
//in questo caso simulato da 10 switch
n=0;
do
{
statosensore=digitalRead(2); //per verificare la posizione del bicchiere
// statosensoreold=digitalRead(2); //per verificare la posizione del bicchiere
// for (n=0; n<8; n++)
if (statosensore==HIGH)
{
if (bitRead(switchVar1,n)==HIGH) //verifica il valore del bit nella variabile 1
{
delay(10); //ritardo variabile a secondo della velocità della macchina
//eccita l’elettrovalvola
bitWrite(Var1,n,HIGH);
digitalWrite(latchPinOUT, LOW); //Pull latch LOW to start sending data
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2); //Send the data byte 2
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1); //Send the data byte 1
digitalWrite(latchPinOUT, HIGH); //Pull latch HIGH to stop sending data

// Serial.println(“Var1_OUT”);
// Serial.println(Var1, BIN);
// Serial.println(int(Var1));

delay(300); //ritardo per la completa eccitazione della bobina dell’elettrovalvola

//diseccita l’elettrovalvola
bitWrite(Var1,n,LOW);
digitalWrite(latchPinOUT, LOW); //Pull latch LOW to start sending data
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2); //Send the data byte 2
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1); //Send the data byte 1
digitalWrite(latchPinOUT, HIGH); //Pull latch HIGH to stop sending data
// statosensorenew=LOW;
delay(150);
}
n=n+1;
// Serial.println(“n”);
// Serial.println(n);
}

} while (n<8);

n=0;
do
{
statosensore=digitalRead(2);
// for (n=0; n<8; n++)
if (statosensore==HIGH)
{
if (bitRead(switchVar2,n)==HIGH) //verifica il valore del bit nella variabile 1
{
delay(10); //ritardo variabile a secondo della velocità della macchina

bitWrite(Var2,n,HIGH);
digitalWrite(latchPinOUT, LOW); //Pull latch LOW to start sending data
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2); //Send the data byte 2
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1); //Send the data byte 1
digitalWrite(latchPinOUT, HIGH); //Pull latch HIGH to stop sending data

// Serial.println(“Var2_OUT”);
// Serial.println(Var2, BIN);
// Serial.println(int(Var2));

delay(300);
bitWrite(Var2,n,LOW);
digitalWrite(latchPinOUT, LOW); //Pull latch LOW to start sending data
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2); //Send the data byte 2
shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1); //Send the data byte 1
digitalWrite(latchPinOUT, HIGH); //Pull latch HIGH to stop sending data
delay(150);
}
n=n+1;
// Serial.println(“n”);
// Serial.println(n);
}
} while (n<8);

} //parentesi di fine loop

//------------------------------------------------end main loop

//shiftIn function

///// just needs the location of the data pin and the clock pin
///// it returns a byte with each bit in the byte corresponding
///// to a pin on the shift register. leftBit 7 = Pin 7 / Bit 0= Pin 0

byte shiftIn(int myDataPin, int myClockPin)
{
int i;
int temp = 0;
int pinState;
byte myDataIn = 0;

pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, INPUT);
//we will be holding the clock pin high 8 times (0,…,7) at the
//end of each time through the for loop

//at the begining of each loop when we set the clock low, it will
//be doing the necessary low to high drop to cause the shift
//register’s DataPin to change state based on the value
//of the next bit in its serial information flow.
//The register transmits the information about the pins from pin 7 to pin 0
//so that is why our function counts down
for (i=7; i>=0; i–)
{
digitalWrite(myClockPin, 0);
delayMicroseconds(0.2);
temp = digitalRead(myDataPin);
if (temp) {
pinState = 1;
//set the bit to 0 no matter what
myDataIn = myDataIn | (1 << i);
}
else {
//turn it off – only necessary for debuging
//print statement since myDataIn starts as 0
pinState = 0;
}

//Debuging print statements
//Serial.print(pinState);
//Serial.print(" ");
//Serial.println (dataIn, BIN);

digitalWrite(myClockPin, 1);

}
//debuging print statements whitespace
//Serial.println();
//Serial.println(myDataIn, BIN);
return myDataIn;
}

il programma funziona bene, ad ogni evento (HIGH) sul pin 2 ho la accensione e spegnimento del led corrispondente allo stato 1 del bit, ora il problema è che dalla fine del loop al suo inizio perdo un evento, qualcuno mi spiega come mai e soprattutto un consiglio per risolvere

grazie
ciao

ciao
così si legge meglio

//codice sviluppato partendo dal lavoro dei sottoelencati autori
//  Author  : Carlyn Maw, Tom Igoe                                    
//  Notes   : Code for using a CD4021B Shift Register
//  Notes   : Code for using a 74hc595 Shift Register 	

/*il seguente codice utilizza le funzioni shifout
 e le funzioni shiftin, viene eseguito il controllo dello stato
 dei contatti su shiftin e la memorizzazione 
 nei registri di shiftin e riprodotti sui led dalla funzione shiftout
 il led sarà in parallelo alla elettrovalvola
 */

//pin per shiftout
//Pin connected to ST_CP of 74HC595
int latchPinOUT = 11;
//Pin connected to SH_CP of 74HC595
int clockPinOUT = 12;
////Pin connected to DS of 74HC595
int dataPinOUT = 10;

//pin per shiftin
//Pin connected to P/SC of 4021
int latchPinIN = 8;
//Pin connected to Q8 of 4021
int dataPinIN = 9;
//Pin connected to CLOCK of 4021
int clockPinIN = 7;

//Define variables to hold the data 
//for shift register.
//starting with a non-zero numbers can help
//troubleshoot
byte switchVar1 = 78;  //01001110
byte switchVar2 = 159; //10011111

byte Var1 = 128;  //01001110
byte Var2 = 159; //10011111

int n=0;            //contatore
int pinsensore=2;    //pin a cui collegarare il sensore induttivo
int statosensore=LOW;  //stato iniziale del sensore


void setup() 
{
  //set pins to output so you can control the shift registers
  //shiftout define pin modes
  pinMode(latchPinOUT, OUTPUT);
  pinMode(clockPinOUT, OUTPUT);
  pinMode(dataPinOUT, OUTPUT);

  //shiftin define pin modes
  pinMode(latchPinIN, OUTPUT);
  pinMode(clockPinIN, OUTPUT); 
  pinMode(dataPinIN, INPUT);
  
  pinMode(pinsensore,INPUT);
 
  Serial.begin(9600);
}

void loop() 
{

  //lettura dello stato dei pin in input
  //shiftin
  //Pulse the latch pin:
  //set it to 1 to collect parallel data
  digitalWrite(latchPinIN,1);
  //set it to 1 to collect parallel data, wait
  delayMicroseconds(50);
  //set it to 0 to transmit data serially  
  digitalWrite(latchPinIN,0);

  //while the shift register is in serial mode
  //collect each shift register into a byte
  //the register attached to the chip comes in first 
  switchVar1 = shiftIn(dataPinIN, clockPinIN);
  switchVar2 = shiftIn(dataPinIN, clockPinIN);
  
 //white space
 // Serial.println("-------------------");
  //Print out the results.
  //leading 0's at the top of the byte 
  //(7, 6, 5, etc) will be dropped before 
  //the first pin that has a high input
  //reading 
 //  Serial.println("switchVar1_IN"); 
 //  Serial.println(switchVar1, BIN);
 //  Serial.println(int(switchVar1));
 //  Serial.println("switchVar2_IN"); 
 //  Serial.println(switchVar2, BIN);
 //  Serial.println(int(switchVar2));
   
/*
  //sezione per shiftout
  //visualizza lo stato complessivo degli switch accendendo i led crrispondenti
  digitalWrite(latchPinOUT, LOW);                         //Pull latch LOW to start sending data
  shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, switchVar2); //Send the data byte 2
  shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, switchVar1); //Send the data byte 1
  digitalWrite(latchPinOUT, HIGH);                        //Pull latch HIGH to stop sending data

 
  //delay so all these print satements can keep up. 
  delay(500);

//sezione per shiftout spegne tutti i led
  Var1=0;
  Var2=0;
  digitalWrite(latchPinOUT, LOW);                         //Pull latch LOW to start sending data
  shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2); //Send the data byte 2
  shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1); //Send the data byte 1
  digitalWrite(latchPinOUT, HIGH);                        //Pull latch HIGH to stop sending data
  delay(500);
  */  
  //questa sezione è il cuore e scopo del programma
  //lo shiftin ha memorizzato lo stato dei 10 sensori HIGH o LOW
  //per la verifica della presenza o meno della pianta nel condotto
  //in questo caso simulato da 10 switch 
  n=0;
do
{
  statosensore=digitalRead(2);  //per verificare la posizione del bicchiere
 // statosensoreold=digitalRead(2);  //per verificare la posizione del bicchiere
// for (n=0; n<8; n++)
 if (statosensore==HIGH)
 {
    if (bitRead(switchVar1,n)==HIGH) //verifica il valore del bit nella variabile 1
    {
//     delay(10);  //ritardo variabile a secondo della velocità della macchina
      //eccita l'elettrovalvola
      bitWrite(Var1,n,HIGH);
      digitalWrite(latchPinOUT, LOW);                       //Pull latch LOW to start sending data
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2);  //Send the data byte 2
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1);    //Send the data byte 1
      digitalWrite(latchPinOUT, HIGH);                      //Pull latch HIGH to stop sending data

//      Serial.println("Var1_OUT"); 
//      Serial.println(Var1, BIN);
//      Serial.println(int(Var1));
      
      delay(300);  //ritardo per la completa apertura del canale
      
      //diseccita l'elettrovalvola      
      bitWrite(Var1,n,LOW);
      digitalWrite(latchPinOUT, LOW);                       //Pull latch LOW to start sending data
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2);  //Send the data byte 2
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1);    //Send the data byte 1
      digitalWrite(latchPinOUT, HIGH);  //Pull latch HIGH to stop sending data
//      statosensorenew=LOW;
delay(150);  //ritardo tra un cilindro e l'altro
    }
n=n+1;
//      Serial.println("n"); 
//      Serial.println(n);
 }
 
} while (n<8);

  n=0;
do
{
  statosensore=digitalRead(2);
// for (n=0; n<8; n++)
 if (statosensore==HIGH)
 {
    if (bitRead(switchVar2,n)==HIGH) //verifica il valore del bit nella variabile 1
    {
//      delay(10);  //ritardo variabile a secondo della velocità della macchina
      
      bitWrite(Var2,n,HIGH);
      digitalWrite(latchPinOUT, LOW);                       //Pull latch LOW to start sending data
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2);  //Send the data byte 2
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1);    //Send the data byte 1
      digitalWrite(latchPinOUT, HIGH);                      //Pull latch HIGH to stop sending data

//    Serial.println("Var2_OUT"); 
//    Serial.println(Var2, BIN);
//    Serial.println(int(Var2));
      
      delay(300);  //ritardo per la completa apertura del canale
      bitWrite(Var2,n,LOW);
      digitalWrite(latchPinOUT, LOW);                       //Pull latch LOW to start sending data
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var2);  //Send the data byte 2
      shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, Var1);    //Send the data byte 1
      digitalWrite(latchPinOUT, HIGH);       //Pull latch HIGH to stop sending data
delay(150);  //ritardo tra un cilindro e l'altro
    }
n=n+1;
 //     Serial.println("n"); 
//      Serial.println(n);
 }
} while (n<8);

}  //parentesi di fine loop


//------------------------------------------------end main loop

//shiftIn function

///// just needs the location of the data pin and the clock pin
///// it returns a byte with each bit in the byte corresponding
///// to a pin on the shift register. leftBit 7 = Pin 7 / Bit 0= Pin 0

byte shiftIn(int myDataPin, int myClockPin)
{
  int i;
  int temp = 0;
  int pinState;
  byte myDataIn = 0;

  pinMode(myClockPin, OUTPUT);
  pinMode(myDataPin, INPUT);
  //we will be holding the clock pin high 8 times (0,..,7) at the
  //end of each time through the for loop

  //at the begining of each loop when we set the clock low, it will
  //be doing the necessary low to high drop to cause the shift
  //register's DataPin to change state based on the value
  //of the next bit in its serial information flow.
  //The register transmits the information about the pins from pin 7 to pin 0
  //so that is why our function counts down
  for (i=7; i>=0; i--)
  {
    digitalWrite(myClockPin, 0);
    delayMicroseconds(0.2);
    temp = digitalRead(myDataPin);
    if (temp) {
      pinState = 1;
      //set the bit to 0 no matter what
      myDataIn = myDataIn | (1 << i);
    }
    else {
      //turn it off -- only necessary for debuging
      //print statement since myDataIn starts as 0
      pinState = 0;
    }

    //Debuging print statements
    //Serial.print(pinState);
    //Serial.print("     ");
    //Serial.println (dataIn, BIN);

    digitalWrite(myClockPin, 1);

  }
  //debuging print statements whitespace
  //Serial.println();
  //Serial.println(myDataIn, BIN);
  return myDataIn;
}
[code]

[/code]