Advertisement
Guest User

11.05.2014 Shiftregister 595 at ATtiny85

a guest
May 23rd, 2014
223
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 2.52 KB | None | 0 0
  1. /*
  2.  * Shift Register 74HC595 Test
  3.  * main.c
  4.  *
  5.  *  Created on: 11.05.2014
  6.  *      Author: koepi
  7.  *
  8.  * A0: DS (serial data input)
  9.  * A1: ST_CP (storage register clock pin, latch)
  10.  * A2: SH_CP (shift register clock pin)
  11.  *
  12.  * A0-A2 are PORTC bits 0 - 2, bitmask 0b00000111 -> 0x07
  13.  */
  14.  
  15. #include "main.h"
  16. #include <avr/io.h>
  17. #include <avr/power.h>
  18.  
  19. typedef enum { false, true } bool;
  20.  
  21. void setup (void) {
  22.     DDRB |= 0x07;  // data direction register - OUTPUT
  23.     PORTB &= ~(0x07);  // data register - all pins LOW
  24.     clock_prescale_set(clock_div_1);
  25. }
  26.  
  27. int main (void) {
  28.     setup();
  29.     // writing to 74HC595 should work like this:
  30.     // set bit on DS (A0), then toggle SH_CP.
  31.     // after 8 bits, toggle latch to view result.
  32.  
  33.     while (1) {  // endless loop
  34.         char i=0;
  35.         int dyn = 15;
  36.         for (int j=0; j<8; j++) {
  37.             i = (1 << j);
  38.             write_reg(i);
  39.             dyn+=5;
  40.             delay(dyn);
  41.         }
  42.         for (int j=7; j>=0; j--) {
  43.             i = (1 << j);
  44.             write_reg(i);
  45.             dyn-=5;
  46.             delay(dyn);
  47.         }
  48.         i=0;
  49.         for (int j=0; j<8; j++) {
  50.             i |= (1 << j);
  51.             write_reg(i);
  52.             dyn+=5;
  53.             delay(dyn);
  54.         }
  55.         for (int j=7; j>=0; j--) {
  56.             i &= ~(1 << j);
  57.             write_reg(i);
  58.             dyn-=5;
  59.             delay(dyn);
  60.         }
  61.         for (int j=0; j<8; j++) {
  62.             i = (1 << j);
  63.             write_reg(i);
  64.             delay(10);
  65.             write_reg(!(i));
  66.             delay(10);
  67.             dyn+=5;
  68.             delay(dyn);
  69.         }
  70.         for (int j=7; j>=0; j--) {
  71.             i = (1 << j);
  72.             write_reg(i);
  73.             delay(10);
  74.             write_reg(!(i));
  75.             delay(10);
  76.             dyn-=5;
  77.             delay(dyn);
  78.         }
  79.         i=0;
  80.         for (int j=0; j<8; j++) {
  81.             i |= (1 << j);
  82.             write_reg(i);
  83.             dyn+=5;
  84.             delay(dyn);
  85.         }
  86.         int del=1;
  87.         int inc=1;
  88.         for (int j=0; j<80; j++) {
  89.             del+=inc;
  90.             if (del<=0 || del> 7) inc=-inc;
  91.             i=0xff;
  92.             write_reg(i);
  93.             delay(del);
  94.             i=0x00;
  95.             write_reg(i);
  96.             delay(del);
  97.         }
  98.         i=0xff;
  99.         write_reg(i);
  100.         for (int j=7; j>=0; j--) {
  101.             i &= ~(1 << j);
  102.             write_reg(i);
  103.             dyn-=5;
  104.             delay(dyn);
  105.         }
  106.     }
  107.  
  108. }
  109.  
  110. void write_reg(char reg) {
  111.     // correction for LED0 on position 7
  112.     bool temp = (reg & 0x80);
  113.     reg <<= 1;
  114.     if (temp) reg |= 0x01;
  115.     PORTB &=~(0b00000010);  // switching off latch
  116.     for (int i=7; i>=0; i--) {
  117.         if (reg & (1 <<i)) {
  118.             PORTB |= 0b00000001;  // setting DS
  119.         } else {
  120.             PORTB &=~(0b00000001);  // resetting DS
  121.         }
  122.         PORTB |= 0b00000100;  // SH_CP HIGH
  123.         PORTB &= ~(0b00000100);  // SH_CP low
  124.     }
  125.     PORTB |= 0b00000010;  // switching on latch
  126. }
  127.  
  128. void delay (int ms) {
  129.     for (int i=0; i<ms; i++) {
  130.         for (int j=0; j<1600; j++) {
  131.             asm volatile ("nop");
  132.         }  // 16000 nops at 16 MHz = 1kHz
  133.     }
  134. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement