Svenska ElektronikForumet

Kod: Markera allt

/* How many shift register chips are daisy-chained.
*/
#define NUMBER_OF_SHIFT_CHIPS   1

/* Width of data (how many ext lines).
*/
#define DATA_WIDTH   NUMBER_OF_SHIFT_CHIPS * 8

/* Width of pulse to trigger the shift register to read and latch.
*/
#define PULSE_WIDTH_USEC   5

/* Optional delay between shift register reads.
*/
#define POLL_DELAY_MSEC   1

/* You will need to change the "int" to "long" If the
 * NUMBER_OF_SHIFT_CHIPS is higher than 2.
*/
#define BYTES_VAL_T unsigned int

int ploadPin        = 31;  // Connects to Parallel load pin the 165
int clockEnablePin  = 30;  // Connects to Clock Enable pin the 165
int dataPin         = 50; // Connects to the Q7 pin the 165
int clockPin        = 52; // Connects to the Clock pin the 165

BYTES_VAL_T pinValues;
BYTES_VAL_T oldPinValues;

/* This function is essentially a "shift-in" routine reading the
 * serial Data from the shift register chips and representing
 * the state of those pins in an unsigned integer (or long).
*/
BYTES_VAL_T read_shift_regs()
{
    long bitVal;
    BYTES_VAL_T bytesVal = 0;

    /* Trigger a parallel Load to latch the state of the data lines,
    */

    digitalWrite(ploadPin, LOW);          // Pull PL low (active) and high (inactive) to load the parallel data into the register
    delayMicroseconds(PULSE_WIDTH_USEC);
    digitalWrite(ploadPin, HIGH);
    delayMicroseconds(PULSE_WIDTH_USEC);
    
    digitalWrite(clockEnablePin, LOW);    // Enable clock CE
    delayMicroseconds(PULSE_WIDTH_USEC);

    /* Loop to read each bit value from the serial out line
     * of the SN74HC165N.
    */
    for(int i = 0; i < DATA_WIDTH; i++)
    {
        bitVal = digitalRead(dataPin);

        /* Set the corresponding bit in bytesVal.
        */
        bytesVal |= (bitVal << ((DATA_WIDTH-1) - i));

        /* Pulse the Clock (rising edge shifts the next bit).
        */
        digitalWrite(clockPin, HIGH);
        delayMicroseconds(PULSE_WIDTH_USEC);
        digitalWrite(clockPin, LOW);
    }

    digitalWrite(clockEnablePin, HIGH);   // Done reading data, disable clock
    
    return(bytesVal);
}

/* Dump the list of zones along with their current status.
*/
void display_pin_values()
{
    Serial.print("Pin States:\r\n");

    for(int i = 0; i < DATA_WIDTH; i++)
    {
        Serial.print("  Pin-");
        Serial.print(i);
        Serial.print(": ");

        if((pinValues >> i) & 1)
            Serial.print("HIGH");
        else
            Serial.print("LOW");

        Serial.print("\r\n");
    }

    Serial.print("\r\n");
}

void setup()
{
    Serial.begin(9600);

    /* Initialize our digital pins...
    */
    pinMode(ploadPin, OUTPUT);
    pinMode(clockEnablePin, OUTPUT);
    pinMode(clockPin, OUTPUT);
    pinMode(dataPin, INPUT);

    digitalWrite(clockPin, LOW);          // Active high
    digitalWrite(ploadPin, HIGH);         // Active low
    digitalWrite(clockEnablePin, HIGH);   // Active low

    /* Read in and display the pin states at startup.
    */
    pinValues = read_shift_regs();
    display_pin_values();
    oldPinValues = pinValues;
}

void loop()
{
    /* Read the state of all zones.
    */
    pinValues = read_shift_regs();

    /* If there was a chage in state, display which ones changed.
    */
    if(pinValues != oldPinValues)
    {
        Serial.print("*Pin value change detected*\r\n");
        display_pin_values();
        oldPinValues = pinValues;
    }

    delay(POLL_DELAY_MSEC);
}

Kod: Markera allt

// Setup pins

const int internalLEDPin = 13; // This pin will control the on-board LED
const int plPin = 31; // This pin will control the parallel load
const int cpPin = 33; // This pin will control the clock pin

void setup() {
  // put your setup code here, to run once:
  pinMode(internalLEDPin, OUTPUT);
  pinMode(plPin, OUTPUT);
  pinMode(cpPin, OUTPUT);
  
  digitalWrite(internalLEDPin, LOW); // LED off
  digitalWrite(plPin, HIGH);  // This is active LOW so I set this inactive for now
  digitalWrite(cpPin, LOW);   // This is active HIGH so I set this inactive for now
}

void loop() {
  // put your main code here, to run repeatedly:
  load_parallel_data_into_register();
  shift_out_data_to_LED();
  
}

void load_parallel_data_into_register()
{
  digitalWrite(plPin, LOW);   // Pull PL low (active) to load parallel data into the register

  // Blink the on-board LED 2 times to show that we set PL active
  for(int i = 0; i < 2; i++) {
    digitalWrite(internalLEDPin, HIGH);
    delay(250);
    digitalWrite(internalLEDPin, LOW);
    delay(250);
  }

  digitalWrite(plPin, HIGH);  // Pull PL high (inactive) so we can shift out the register
  delay(1000);                // Wait for 1 sec
}

void shift_out_data_to_LED()
{
  // Send 8 clock-signals to CP to shift out the register
  for(int i = 0; i < 8; i++) {
    digitalWrite(cpPin, HIGH);          // Activate clock-signal
    digitalWrite(internalLEDPin, HIGH); // Turn on on-board LED to show that we are sending clock-signals
    delay(1000);                        // Wait for 1 sec
    digitalWrite(cpPin, LOW);           // Deactivate clock-signal
    digitalWrite(internalLEDPin, LOW);  // Turn on-board LED off
    delay(1000);                        // Wait for 1 sec
  }

  // Show that all data has been shifted out by lighting the on-board LED for 5 secs
  digitalWrite(internalLEDPin, HIGH);
  delay(5000);
  digitalWrite(internalLEDPin, LOW);
  delay(1000);
}