Operácie

Bežiace svetlo s obvodom 74HC595: Rozdiel medzi revíziami

Zo stránky SensorWiki

← Predchádzajúca úprava
StudentMIPS (diskusia | príspevky)
sensor
2 676 editací
StudentMIPS (diskusia | príspevky)
sensor
2 676 editací
 
(16 medziľahlých úprav od rovnakého používateľa nie je zobrazených.)
Riadok 1: Riadok 1:
Záverečný projekt predmetu MIPS / LS2025 - '''Meno Priezvisko'''
Záverečný projekt predmetu MIPS / LS2025 - '''Andrej Bariš'''




Riadok 11: Riadok 11:


'''Literatúra:'''  
'''Literatúra:'''  
* [http://ap.urpi.fei.stuba.sk/sensorwiki/index.php/Acrob_technical_description Dokumentácia k doske Acrob]
 
* [http://www.humanbenchmark.com/tests/reactiontime/index.php Vyskúšajte si zmerať reakciu on-line]
* Arduino UNO v3 - [https://docs.arduino.cc/resources/datasheets/A000066-datasheet.pdf datasheet]
*
* Posuvný register 74HC595 - [https://www.ti.com/lit/ds/symlink/sn74hc595.pdf datasheet]
* Posuvný register 74HC595 - [https://www.ti.com/lit/ds/symlink/sn74hc595.pdf datasheet]
* LED displej  BL-AR10Z2510 - [http://betlux.com/product/LED_light_bar/BL-AR10Z2510.pdf datasheet]
* LED displej  BL-AR10Z2510 - [http://betlux.com/product/LED_light_bar/BL-AR10Z2510.pdf datasheet]
Riadok 25: Riadok 24:
== Analýza  a opis riešenia ==
== Analýza  a opis riešenia ==


Opíšte sem čo a ako ste spravili, ak treba, doplňte obrázkami...
Pre toto zapojenie využijeme 8 bitový serial-in, parallel-out posuvný register SN74HC595N. Použijeme ho na rozšírenie výstupov mikrokontrolera aby sme mohli ovládať viac LED diód naraz.  
Podrobne opíšte použité komponenty (okrem základnej dosky s ATmega328P procesorom), pridajte linky na datasheety alebo opis obvodu.  
 
[[Súbor:PosuvReg.png_small|400px|thumb|center|Posúvny register SN74HC595n.]]
 
Na zobrazenie vzorov použijeme 10 LED diódový displej BL-AR10Z2510, v našom prípade bude 8 LED diód zapojených z posúvneho registra a ďalšie 2 budú priamo zapojené z mikrokontroleru.


[[Súbor:GeminiAI-image3.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]
[[Súbor:LED_REAL.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]


Nezabudnite doplniť schému zapojenia! V texte by ste mali opísať základné veci zo zapojenia, samotná schéma nie je dostačujúci opis.
Každá LED dióda je zapojená v sérii s 470Ω odporom.


[[Súbor:Schema zapojenia.drawio.png|600px|thumb|center|Schéma zapojenia LED a odporov s registrom 74HC595.]]
[[Súbor:REZ_REAL.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]
 
Podľa datasheetu posuvného registra pripojíme na jeho napájanie aj 100nF kondenzátor pre väčšiu stabilitu.
 
[[Súbor:KOND_REAL.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]
 
Na ovládanie celého systému sme použili mikrokontrolér Arduino UNO. Zapojenie jednotlivých pinov je nasledovné:
 
SER → D5 (Poslanie dát)
 
RCLK → D4 (Latch clock)
 
SCLK → D3 (Serial Clock)
 
SRCLR → D2 (Serial Clear)
 
OE → GND (Output Enable)


LED 9 a LED 10 → D0 a D1


[[Súbor:Schema zapojenia.drawio.png|600px|thumb|center|Schéma zapojenia LED a odporov s registrom 74HC595.]]




=== Algoritmus a program ===
=== Algoritmus a program ===


Algoritmus programu využíva toto a toto, základné funkcie sú takéto a voláma ich tuto...  
Algoritmus programu využíva 2 vlastné funkcie a to "svietenie" (Zabezpečuje že 2 LED-ky ovládané priamo z Arduina sa budú zasviecovať s tými ovládanými shift registrom) a "OutSer" (Zabezpečuje prenos dát do posuvného registra a následné vyobrazenie vzorov pomocou registra). Takisto sme si vytvorili aj knižnicu "PATTERNS.h" kde máme uložené všetky vzory ich dĺžky a počet opakovaní v jednom loope.
Výpis kódu je nižšie...
 
Program sa automaticky zapne zopnutím Arduina a opakuje v nekonečnom while cykle všetkých 13 po sebe idúcich vzorov. Do budúcna by bolo program vhodné doplniť o zapínaciu sekvenciu a možné posúvanie sa medzi vzormi po vstupe napr. z klávesnice pomocou UART alebo stlačením tlačidla.




<tabs>
<tabs>
<tab name="AVR C-code"><syntaxhighlight  lang="c++" style="background: LightYellow;">
<tab name="AVR C-code"><syntaxhighlight  lang="c++" style="background: LightYellow;">
#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/io.h>
#include <util/delay.h>
#include "PATTERNS.h"
#define LED9 PD0
#define LED8 PD1
#define SER PD5
#define RCLK PD4
#define SCLK PD3
#define SRCLR PD2


int main(void)
void OutSer(int data){
{
    for (int i = 7; i >= 0; i--) {
  unsigned int measuredValue;
        if (data & (1 << i)) // Porovnávame či bit sa rovná 1
            PORTD |= (1 << SER);
        else
            PORTD &= ~(1 << SER);
_delay_us(25);
        PORTD |= (1 << SCLK); // Pošleme signál na prijmutie bitu na SER pine
        _delay_us(20);
        PORTD &= ~(1 << SCLK);
_delay_us(20);
    }
    PORTD |= (1 << RCLK); // Pošleme signál na výstup registra
    _delay_us(20);
    PORTD &= ~(1 << RCLK);
_delay_us(20);
}


  while (1)
void svietenie (int pattern){
  {
int posunutedata = pattern & 0xFF;
    /*  relax  */
int led8 = (pattern >> 8) & 0x01; // LED8 priradíme 9-tý bit
  }
int led9 = (pattern >> 9) & 0x01; // LED9 priradíme 10-tý bit
OutSer(posunutedata);
if (led8) PORTD |= (1 << LED8); // Ak led8 sa rovná 1 tak zasvieti led-ku
    else      PORTD &= ~(1 << LED8);


   return(0);
    if (led9) PORTD |= (1 << LED9); // Ak led9 sa rovná 1 tak zasvieti led-ku
    else      PORTD &= ~(1 << LED9);
}
 
int main() {
//Inicializácia
DDRD |= (1 << SER) | (1 << RCLK) | (1 << SCLK) | (1 << SRCLR); // Nastavíme output pre vstupy do shift registra
DDRD |= (1 << LED8) | (1 << LED9); // Nastavíme output pre LED-ky ovládané priamo mikrokontrolerom
PORTD &= ~(1 << SRCLR);  // Vyčistíme register
_delay_us(20);
PORTD |= (1 << SRCLR);   // Zapneme shift register
 
int patternCount = sizeof(Patterns) / sizeof(Patterns[0]);
 
while (1) {
for (int i = 0; i < patternCount; i++) {
for (int r = 0; r < Reps[i]; r++) {
for (int j = 0; j < PatternL[i]; j++) {
svietenie(Patterns[i][j]);
_delay_ms(100);
}
}
}
}
}
}


</syntaxhighlight ></tab>
</syntaxhighlight ></tab>
<tab name="filename.h"><syntaxhighlight  lang="c++" style="background: LightYellow;">
<tab name="PATTERNS.h"><syntaxhighlight  lang="c++" style="background: LightYellow;">
#include <avr/io.h>
#ifndef PATTERNS_H_
#define PATTERNS_H_
 
int pattern1[] = {
0b0000000001,
0b0000000011,
0b0000000111,
0b0000001111,
0b0000011111,
0b0000111111,
0b0001111111,
0b0011111111,
0b0111111111,
0b1111111111,
0b1111111110,
0b1111111100,
0b1111111000,
0b1111110000,
0b1111100000,
0b1111000000,
0b1110000000,
0b1100000000,
0b1000000000
};
int pattern2[] = {
0b1000000000,
0b1100000000,
0b1110000000,
0b1111000000,
0b1111100000,
0b1111110000,
0b1111111000,
0b1111111100,
0b1111111110,
0b1111111111,
0b0111111111,
0b0011111111,
0b0001111111,
0b0000111111,
0b0000011111,
0b0000001111,
0b0000000111,
0b0000000011,
0b0000000001
};
int pattern3[] = {
0b1010101010,
0b0101010101,
0b1010101010,
0b0101010101
};
int pattern4[] = {
0b1000000000,
0b1100000000,
0b1110000000,
0b1111000000,
0b1111100000,
0b1111110000,
0b1111111000,
0b1111111100,
0b1111111110,
0b1111111111,
0b1111111110,
0b1111111100,
0b1111111000,
0b1111110000,
0b1111100000,
0b1111000000,
0b1110000000,
0b1100000000,
0b1000000000
};
int pattern5[] = {
0b0000000001,
0b0000000011,
0b0000000111,
0b0000001111,
0b0000011111,
0b0000111111,
0b0001111111,
0b0011111111,
0b0111111111,
0b1111111111,
0b0111111111,
0b0011111111,
0b0001111111,
0b0000111111,
0b0000011111,
0b0000001111,
0b0000000111,
0b0000000011,
0b0000000001
};
int pattern6[] = {
0b1000000001,
    0b1100000011,
    0b1110000111,
    0b1111001111,
    0b1111111111,
    0b0111111110,
    0b0011111100,
    0b0001111000,
    0b0000110000,
0b0000000000,
};
int pattern7[] = {
0b1000000000,
    0b0100000000,
    0b0010000000,
    0b0001000000,
    0b0000100000,
    0b0000010000,
    0b0000001000,
    0b0000000100,
    0b0000000010,
    0b0000000001,
0b1000000001,
    0b0100000001,
    0b0010000001,
    0b0001000001,
    0b0000100001,
    0b0000010001,
0b0000001001,
    0b0000000101,
0b1000000011,
    0b0100000011,
    0b0010000011,
    0b0001000011,
    0b0000100011,
    0b0000010011,
    0b0000001011,
    0b0000000111,
0b1000000111,
    0b0100000111,
    0b0010000111,
    0b0001000111,
    0b0000100111,
    0b0000010111,
    0b0000001111,
0b1000001111,
    0b0100001111,
    0b0010001111,
    0b0001001111,
    0b0000101111,
    0b0000011111,
0b1000011111,
    0b0100011111,
    0b0010011111,
    0b0001011111,
    0b0000111111,
0b1000111111,
    0b0100111111,
    0b0010111111,
    0b0001111111,
0b1001111111,
    0b0101111111,
    0b0011111111,
0b1011111111,
    0b0111111111,
0b1111111111,
0b0111111111,
0b0011111111,
0b0001111111,
0b0000111111,
0b0000011111,
0b0000001111,
0b0000000111,
0b0000000011,
0b0000000001,
0b0000000000,
};
int pattern8[] = {
0b0000000001,
0b0000000010,
0b0000000100,
0b0000001000,
0b0000010000,
0b0000100000,
0b0001000000,
0b0010000000,
0b0100000000,
0b1000000000,
0b1000000010,
0b1000000100,
0b1000001000,
0b1000010000,
0b1000100000,
0b1001000000,
0b1010000000,
0b1100000000,
0b1100000001,
0b1100000010,
0b1100000100,
0b1100001000,
0b1100010000,
0b1100100000,
0b1101000000,
0b1110000000,
0b1110000001,
0b1110000010,
0b1110000100,
0b1110001000,
0b1110010000,
0b1110100000,
0b1111000000,
0b1111000001,
0b1111000010,
0b1111000100,
0b1111001000,
0b1111010000,
0b1111100000,
0b1111100001,
0b1111100010,
0b1111100100,
0b1111101000,
0b1111110000,
0b1111110001,
0b1111110010,
0b1111110100,
0b1111111000,
0b1111111001,
0b1111111010,
0b1111111100,
0b1111111101,
0b1111111110,
0b1111111111,
0b1111111110,
0b1111111100,
0b1111111000,
0b1111110000,
0b1111100000,
0b1111000000,
0b1110000000,
0b1100000000,
0b1000000000
};
int pattern9[] = {
0b0000110000,
0b0001111000,
0b0011111100,
0b0111111110,
0b1111111111,
    0b1111001111,
    0b1110000111,
    0b1100000011,
    0b1000000001, 
    0b0000000000
};
int pattern10[] = {
0b1000000000,
    0b0100000000,
    0b0010000000,
    0b0001000000,
    0b0000100000,
    0b0000010000,
    0b0000001000,
    0b0000000100,
    0b0000000010,
    0b0000000001,
0b1000000001,
    0b0100000001,
    0b0010000001,
    0b0001000001,
    0b0000100001,
    0b0000010001,
0b0000001001,
    0b0000000101,
0b1000000011,
    0b0100000011,
    0b0010000011,
    0b0001000011,
    0b0000100011,
    0b0000010011,
    0b0000001011,
    0b0000000111,
0b1000000111,
    0b0100000111,
    0b0010000111,
    0b0001000111,
    0b0000100111,
    0b0000010111,
    0b0000001111,
0b1000001111,
    0b0100001111,
    0b0010001111,
    0b0001001111,
    0b0000101111,
    0b0000011111,
0b1000011111,
    0b0100011111,
    0b0010011111,
    0b0001011111,
    0b0000111111,
0b1000111111,
    0b0100111111,
    0b0010111111,
    0b0001111111,
0b1001111111,
    0b0101111111,
    0b0011111111,
0b1011111111,
    0b0111111111,
0b1111111111,
0b1111111110,
0b1111111100,
0b1111111000,
0b1111110000,
0b1111100000,
0b1111000000,
0b1110000000,
0b1100000000,
0b1000000000
};
int pattern11[] = {
0b0000000001,
0b0000000010,
0b0000000100,
0b0000001000,
0b0000010000,
0b0000100000,
0b0001000000,
0b0010000000,
0b0100000000,
0b1000000000,
0b1000000010,
0b1000000100,
0b1000001000,
0b1000010000,
0b1000100000,
0b1001000000,
0b1010000000,
0b1100000000,
0b1100000001,
0b1100000010,
0b1100000100,
0b1100001000,
0b1100010000,
0b1100100000,
0b1101000000,
0b1110000000,
0b1110000001,
0b1110000010,
0b1110000100,
0b1110001000,
0b1110010000,
0b1110100000,
0b1111000000,
0b1111000001,
0b1111000010,
0b1111000100,
0b1111001000,
0b1111010000,
0b1111100000,
0b1111100001,
0b1111100010,
0b1111100100,
0b1111101000,
0b1111110000,
0b1111110001,
0b1111110010,
0b1111110100,
0b1111111000,
0b1111111001,
0b1111111010,
0b1111111100,
0b1111111101,
0b1111111110,
0b1111111111,
0b0111111111,
0b0011111111,
0b0001111111,
0b0000111111,
0b0000011111,
0b0000001111,
0b0000000111,
0b0000000011,
0b0000000001
};
int pattern12[] = {
0b1000000000,
    0b0100000000,
    0b0010000000,
    0b0001000000,
    0b0000100000,
    0b0000010000,
    0b0000001000,
    0b0000000100,
    0b0000000010,
    0b0000000001,
0b1000000001,
    0b0100000001,
    0b0010000001,
    0b0001000001,
    0b0000100001,
    0b0000010001,
0b0000001001,
    0b0000000101,
0b1000000011,
    0b0100000011,
    0b0010000011,
    0b0001000011,
    0b0000100011,
    0b0000010011,
    0b0000001011,
    0b0000000111,
0b1000000111,
    0b0100000111,
    0b0010000111,
    0b0001000111,
    0b0000100111,
    0b0000010111,
    0b0000001111,
0b1000001111,
    0b0100001111,
    0b0010001111,
    0b0001001111,
    0b0000101111,
    0b0000011111,
0b1000011111,
    0b0100011111,
    0b0010011111,
    0b0001011111,
    0b0000111111,
0b1000111111,
    0b0100111111,
    0b0010111111,
    0b0001111111,
0b1001111111,
    0b0101111111,
    0b0011111111,
0b1011111111,
    0b0111111111,
0b1111111111,
    0b0111111111,
    0b1011111111,
    0b0011111111,
    0b0101111111,
    0b1001111111,
    0b0001111111,
    0b0010111111,
    0b0100111111,
    0b1000111111,
    0b0000111111,
    0b0001011111,
    0b0010011111,
    0b0100011111,
    0b1000011111,
    0b0000011111,
    0b0000101111,
    0b0001001111,
    0b0010001111,
    0b0100001111,
    0b1000001111,
    0b0000001111,
    0b0000010111,
    0b0000100111,
    0b0001000111,
    0b0010000111,
    0b0100000111,
    0b1000000111,
    0b0000000111,
    0b0000001011,
    0b0000010011,
    0b0000100011,
    0b0001000011,
    0b0010000011,
    0b0100000011,
    0b1000000011,
0b0000000011,
    0b0000000101,
    0b0000001001,
    0b0000010001,
    0b0000100001,
    0b0001000001,
    0b0010000001,
    0b0100000001,
    0b1000000001,
    0b0000000001,
    0b0000000010,
    0b0000000100,
    0b0000001000,
    0b0000010000,
    0b0000100000,
    0b0001000000,
    0b0010000000,
    0b0100000000,
0b1000000000,
0b0000000000
};
int pattern13[] = {
    0b0000000001,
    0b0000000010,
    0b0000000100,
    0b0000001000,
    0b0000010000,
    0b0000100000,
    0b0001000000,
    0b0010000000,
    0b0100000000,
    0b1000000000,
    0b1000000001,
    0b1000000010,
    0b1000000100,
    0b1000001000,
    0b1000010000,
    0b1000100000,
    0b1001000000,
    0b1010000000,
    0b1100000001,
    0b1100000010,
    0b1100000100,
    0b1100001000,
    0b1100010000,
    0b1100100000,
    0b1101000000,
    0b1110000000,
    0b1110000001,
    0b1110000010,
    0b1110000100,
    0b1110001000,
    0b1110010000,
    0b1110100000,
    0b1111000000,
    0b1111000001,
    0b1111000010,
    0b1111000100,
    0b1111001000,
    0b1111010000,
    0b1111100000,
    0b1111100001,
    0b1111100010,
    0b1111100100,
    0b1111101000,
    0b1111110000,
    0b1111110001,
    0b1111110010,
    0b1111110100,
    0b1111111000,
    0b1111111001,
    0b1111111010,
    0b1111111100,
    0b1111111101,
    0b1111111110,
    0b1111111111,
0b1111111110,
0b1111111101,
0b1111111100,
    0b1111111010,
    0b1111111001,
0b1111111000,
    0b1111110100,
    0b1111110010,
    0b1111110001,
0b1111110000,
    0b1111101000,
    0b1111100100,
    0b1111100010,
    0b1111100001,
0b1111100000,
    0b1111010000,
    0b1111001000,
    0b1111000100,
    0b1111000010,
    0b1111000001,
0b1111000000,
    0b1110100000,
    0b1110010000,
    0b1110001000,
    0b1110000100,
0b1110000010,
0b1110000001,
    0b1110000000,
    0b1101000000,
    0b1100100000,
    0b1100010000,
    0b1100001000,
    0b1100000100,
    0b1100000010,
    0b1100000001,
    0b1100000000,
    0b1010000000,
    0b1001000000,
    0b1000100000,
    0b1000010000,
    0b1000001000,
    0b1000000100,
    0b1000000010,
    0b1000000001,
0b1000000000,
0b0100000000,
0b0010000000,
0b0001000000,
0b0000100000,
0b0000010000,
0b0000001000,
0b0000000100,
0b0000000010,
0b0000000001,
0b0000000000
};
 
int* Patterns[] = { pattern1, pattern2, pattern3, pattern4, pattern5, pattern6, pattern7, pattern8, pattern9, pattern10, pattern11, pattern12, pattern13};
int PatternL[] = { 19, 19, 4, 19, 19, 10, 63, 63, 10, 63, 63, 109, 109};
int Reps[]= {1,1,8,1,1,5,1,1,5,1,1,1,1};
 


void adc_init(void);                                  // A/D converter initialization


unsigned int adc_read(char a_pin);
#endif /* PATTERNS_H_ */
</syntaxhighlight ></tab>
</syntaxhighlight ></tab>
</tabs>
</tabs>


Pridajte sem aj zbalený kompletný projekt, napríklad takto (použite jednoznačné pomenovanie, nemôžeme mať na serveri 10x ''zdrojaky.zip'':
Zdrojový kód: [[Médiá:Bariš_Andrej_74HC595.zip|Bariš_Andrej_74HC595.zip]]
 
Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]


=== Overenie ===
=== Overenie ===
Funkčnost nášho zariadenia sme si overili sledovaním LED displeja, na ktorom sme pozorovali správnosť vyobrazených vzorov.


Ako ste overili funkciu, napríklad... Na používanie našej aplikácie stačia dve tlačítka a postup používania je opísaný v sekcii popis riešenia.
Na konci uvádzame fotku hotového zariadenia.


[[Súbor:Zapojenie_REAL.jpg|400px|thumb|center|Aplikácia.]]
[[Súbor:Zapojenie_REAL.jpg|400px|thumb|center|Zapojenie s 74HC595.]]


'''Video:'''
'''Video:'''
<center><youtube>D0UnqGm_miA</youtube></center>
<center><youtube>uI6lJeCnBog</youtube></center>




Aktuálna revízia z 09:15, 13. jún 2025

Záverečný projekt predmetu MIPS / LS2025 - Andrej Bariš


Zadanie

Zapojte k mikropočítaču LED displej BL-AR10Z2510 s rezistrovou sieťou pomocou posuvného registra 74HC595 aby sme ušetrili vstupno-výstupné porty. Svetelné vzory implementujte podľa článku https://www.engineersgarage.com/articles-arduino-led-chaser-sequencer-13-light-patterns/

Vývojová doska ACROB.

Literatúra:



Analýza a opis riešenia

Pre toto zapojenie využijeme 8 bitový serial-in, parallel-out posuvný register SN74HC595N. Použijeme ho na rozšírenie výstupov mikrokontrolera aby sme mohli ovládať viac LED diód naraz.

Posúvny register SN74HC595n.

Na zobrazenie vzorov použijeme 10 LED diódový displej BL-AR10Z2510, v našom prípade bude 8 LED diód zapojených z posúvneho registra a ďalšie 2 budú priamo zapojené z mikrokontroleru.

Celkový pohľad na zariadenie.

Každá LED dióda je zapojená v sérii s 470Ω odporom.

Celkový pohľad na zariadenie.

Podľa datasheetu posuvného registra pripojíme na jeho napájanie aj 100nF kondenzátor pre väčšiu stabilitu.

Celkový pohľad na zariadenie.

Na ovládanie celého systému sme použili mikrokontrolér Arduino UNO. Zapojenie jednotlivých pinov je nasledovné:

SER → D5 (Poslanie dát)

RCLK → D4 (Latch clock)

SCLK → D3 (Serial Clock)

SRCLR → D2 (Serial Clear)

OE → GND (Output Enable)

LED 9 a LED 10 → D0 a D1

Schéma zapojenia LED a odporov s registrom 74HC595.


Algoritmus a program

Algoritmus programu využíva 2 vlastné funkcie a to "svietenie" (Zabezpečuje že 2 LED-ky ovládané priamo z Arduina sa budú zasviecovať s tými ovládanými shift registrom) a "OutSer" (Zabezpečuje prenos dát do posuvného registra a následné vyobrazenie vzorov pomocou registra). Takisto sme si vytvorili aj knižnicu "PATTERNS.h" kde máme uložené všetky vzory ich dĺžky a počet opakovaní v jednom loope.

Program sa automaticky zapne zopnutím Arduina a opakuje v nekonečnom while cykle všetkých 13 po sebe idúcich vzorov. Do budúcna by bolo program vhodné doplniť o zapínaciu sekvenciu a možné posúvanie sa medzi vzormi po vstupe napr. z klávesnice pomocou UART alebo stlačením tlačidla. 


#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/delay.h>
#include "PATTERNS.h"

#define LED9 PD0
#define LED8 PD1
#define SER PD5
#define RCLK PD4
#define SCLK PD3
#define SRCLR PD2

void OutSer(int data){
    for (int i = 7; i >= 0; i--) {
        if (data & (1 << i))	// Porovnávame či bit sa rovná 1
            PORTD |= (1 << SER);
        else
            PORTD &= ~(1 << SER);
		_delay_us(25);
        PORTD |= (1 << SCLK); // Pošleme signál na prijmutie bitu na SER pine
        _delay_us(20);
        PORTD &= ~(1 << SCLK);
		_delay_us(20);
    }
    PORTD |= (1 << RCLK); // Pošleme signál na výstup registra
    _delay_us(20);
    PORTD &= ~(1 << RCLK);
	_delay_us(20);
}

void svietenie (int pattern){
	int posunutedata = pattern & 0xFF;
	int led8 = (pattern >> 8) & 0x01;	// LED8 priradíme 9-tý bit
	int led9 = (pattern >> 9) & 0x01;	// LED9 priradíme 10-tý bit
	
	OutSer(posunutedata);
	if (led8) PORTD |= (1 << LED8);		// Ak led8 sa rovná 1 tak zasvieti led-ku
    else      PORTD &= ~(1 << LED8);

    if (led9) PORTD |= (1 << LED9);		// Ak led9 sa rovná 1 tak zasvieti led-ku
    else      PORTD &= ~(1 << LED9); 
}

int main() {
	
	//Inicializácia
	DDRD |= (1 << SER) | (1 << RCLK) | (1 << SCLK) | (1 << SRCLR); // Nastavíme output pre vstupy do shift registra
	DDRD |= (1 << LED8) | (1 << LED9); // Nastavíme output pre LED-ky ovládané priamo mikrokontrolerom
	
	PORTD &= ~(1 << SRCLR);  // Vyčistíme register
	_delay_us(20);
	PORTD |= (1 << SRCLR);   // Zapneme shift register

	
	int patternCount = sizeof(Patterns) / sizeof(Patterns[0]);

	while (1) {
		for (int i = 0; i < patternCount; i++) {
			for (int r = 0; r < Reps[i]; r++) {
				for (int j = 0; j < PatternL[i]; j++) {
					svietenie(Patterns[i][j]);
					_delay_ms(100);
				}
			}
		}
	}
}

#ifndef PATTERNS_H_
#define PATTERNS_H_

int pattern1[] = {
	0b0000000001,
	0b0000000011,
	0b0000000111,
	0b0000001111,
	0b0000011111,
	0b0000111111,
	0b0001111111,
	0b0011111111,
	0b0111111111,
	0b1111111111,
	0b1111111110,
	0b1111111100,
	0b1111111000,
	0b1111110000,
	0b1111100000,
	0b1111000000,
	0b1110000000,
	0b1100000000,
	0b1000000000
};
int pattern2[] = {
	0b1000000000,
	0b1100000000,
	0b1110000000,
	0b1111000000,
	0b1111100000,
	0b1111110000,
	0b1111111000,
	0b1111111100,
	0b1111111110,
	0b1111111111,
	0b0111111111,
	0b0011111111,
	0b0001111111,
	0b0000111111,
	0b0000011111,
	0b0000001111,
	0b0000000111,
	0b0000000011,
	0b0000000001
};
int pattern3[] = {
	0b1010101010,
	0b0101010101,
	0b1010101010,
	0b0101010101
};
int pattern4[] = {
	0b1000000000,
	0b1100000000,
	0b1110000000,
	0b1111000000,
	0b1111100000,
	0b1111110000,
	0b1111111000,
	0b1111111100,
	0b1111111110,
	0b1111111111,
	0b1111111110,
	0b1111111100,
	0b1111111000,
	0b1111110000,
	0b1111100000,
	0b1111000000,
	0b1110000000,
	0b1100000000,
	0b1000000000
};
int pattern5[] = {
	0b0000000001,
	0b0000000011,
	0b0000000111,
	0b0000001111,
	0b0000011111,
	0b0000111111,
	0b0001111111,
	0b0011111111,
	0b0111111111,
	0b1111111111,
	0b0111111111,
	0b0011111111,
	0b0001111111,
	0b0000111111,
	0b0000011111,
	0b0000001111,
	0b0000000111,
	0b0000000011,
	0b0000000001
};
int pattern6[] = {
	0b1000000001,
    0b1100000011,
    0b1110000111,
    0b1111001111,
    0b1111111111,
    0b0111111110,
    0b0011111100,
    0b0001111000,
    0b0000110000,
	0b0000000000,
};
int pattern7[] = {
	0b1000000000,
    0b0100000000,
    0b0010000000,
    0b0001000000,
    0b0000100000,
    0b0000010000,
    0b0000001000,
    0b0000000100,
    0b0000000010,
    0b0000000001,
	0b1000000001,
    0b0100000001,
    0b0010000001,
    0b0001000001,
    0b0000100001,
    0b0000010001,
	0b0000001001,
    0b0000000101,
	0b1000000011,
    0b0100000011,
    0b0010000011,
    0b0001000011,
    0b0000100011,
    0b0000010011,
    0b0000001011,
    0b0000000111,
	0b1000000111,
    0b0100000111,
    0b0010000111,
    0b0001000111,
    0b0000100111,
    0b0000010111,
    0b0000001111,
	0b1000001111,
    0b0100001111,
    0b0010001111,
    0b0001001111,
    0b0000101111,
    0b0000011111,
	0b1000011111,
    0b0100011111,
    0b0010011111,
    0b0001011111,
    0b0000111111,
	0b1000111111,
    0b0100111111,
    0b0010111111,
    0b0001111111,
	0b1001111111,
    0b0101111111,
    0b0011111111,
	0b1011111111,
    0b0111111111,
	0b1111111111,
	0b0111111111,
	0b0011111111,
	0b0001111111,
	0b0000111111,
	0b0000011111,
	0b0000001111,
	0b0000000111,
	0b0000000011,
	0b0000000001,
	0b0000000000,
};
int pattern8[] = {
	0b0000000001,
	0b0000000010,
	0b0000000100,
	0b0000001000,
	0b0000010000,
	0b0000100000,
	0b0001000000,
	0b0010000000,
	0b0100000000,
	0b1000000000,
	0b1000000010,
	0b1000000100,
	0b1000001000,
	0b1000010000,
	0b1000100000,
	0b1001000000,
	0b1010000000,
	0b1100000000,
	0b1100000001,
	0b1100000010,
	0b1100000100,
	0b1100001000,
	0b1100010000,
	0b1100100000,
	0b1101000000,
	0b1110000000,
	0b1110000001,
	0b1110000010,
	0b1110000100,
	0b1110001000,
	0b1110010000,
	0b1110100000,
	0b1111000000,
	0b1111000001,
	0b1111000010,
	0b1111000100,
	0b1111001000,
	0b1111010000,
	0b1111100000,
	0b1111100001,
	0b1111100010,
	0b1111100100,
	0b1111101000,
	0b1111110000,
	0b1111110001,
	0b1111110010,
	0b1111110100,
	0b1111111000,
	0b1111111001,
	0b1111111010,
	0b1111111100,
	0b1111111101,
	0b1111111110,
	0b1111111111,
	0b1111111110,
	0b1111111100,
	0b1111111000,
	0b1111110000,
	0b1111100000,
	0b1111000000,
	0b1110000000,
	0b1100000000,
	0b1000000000
};
int pattern9[] = {
	0b0000110000,
	0b0001111000,
	0b0011111100,
	0b0111111110,
	0b1111111111,
    0b1111001111,
    0b1110000111,
    0b1100000011,
    0b1000000001,  
    0b0000000000
};
int pattern10[] = {
	0b1000000000,
    0b0100000000,
    0b0010000000,
    0b0001000000,
    0b0000100000,
    0b0000010000,
    0b0000001000,
    0b0000000100,
    0b0000000010,
    0b0000000001,
	0b1000000001,
    0b0100000001,
    0b0010000001,
    0b0001000001,
    0b0000100001,
    0b0000010001,
	0b0000001001,
    0b0000000101,
	0b1000000011,
    0b0100000011,
    0b0010000011,
    0b0001000011,
    0b0000100011,
    0b0000010011,
    0b0000001011,
    0b0000000111,
	0b1000000111,
    0b0100000111,
    0b0010000111,
    0b0001000111,
    0b0000100111,
    0b0000010111,
    0b0000001111,
	0b1000001111,
    0b0100001111,
    0b0010001111,
    0b0001001111,
    0b0000101111,
    0b0000011111,
	0b1000011111,
    0b0100011111,
    0b0010011111,
    0b0001011111,
    0b0000111111,
	0b1000111111,
    0b0100111111,
    0b0010111111,
    0b0001111111,
	0b1001111111,
    0b0101111111,
    0b0011111111,
	0b1011111111,
    0b0111111111,
	0b1111111111,
	0b1111111110,
	0b1111111100,
	0b1111111000,
	0b1111110000,
	0b1111100000,
	0b1111000000,
	0b1110000000,
	0b1100000000,
	0b1000000000
};
int pattern11[] = {
	0b0000000001,
	0b0000000010,
	0b0000000100,
	0b0000001000,
	0b0000010000,
	0b0000100000,
	0b0001000000,
	0b0010000000,
	0b0100000000,
	0b1000000000,
	0b1000000010,
	0b1000000100,
	0b1000001000,
	0b1000010000,
	0b1000100000,
	0b1001000000,
	0b1010000000,
	0b1100000000,
	0b1100000001,
	0b1100000010,
	0b1100000100,
	0b1100001000,
	0b1100010000,
	0b1100100000,
	0b1101000000,
	0b1110000000,
	0b1110000001,
	0b1110000010,
	0b1110000100,
	0b1110001000,
	0b1110010000,
	0b1110100000,
	0b1111000000,
	0b1111000001,
	0b1111000010,
	0b1111000100,
	0b1111001000,
	0b1111010000,
	0b1111100000,
	0b1111100001,
	0b1111100010,
	0b1111100100,
	0b1111101000,
	0b1111110000,
	0b1111110001,
	0b1111110010,
	0b1111110100,
	0b1111111000,
	0b1111111001,
	0b1111111010,
	0b1111111100,
	0b1111111101,
	0b1111111110,
	0b1111111111,
	0b0111111111,
	0b0011111111,
	0b0001111111,
	0b0000111111,
	0b0000011111,
	0b0000001111,
	0b0000000111,
	0b0000000011,
	0b0000000001
};
int pattern12[] = {
	0b1000000000,
    0b0100000000,
    0b0010000000,
    0b0001000000,
    0b0000100000,
    0b0000010000,
    0b0000001000,
    0b0000000100,
    0b0000000010,
    0b0000000001,
	0b1000000001,
    0b0100000001,
    0b0010000001,
    0b0001000001,
    0b0000100001,
    0b0000010001,
	0b0000001001,
    0b0000000101,
	0b1000000011,
    0b0100000011,
    0b0010000011,
    0b0001000011,
    0b0000100011,
    0b0000010011,
    0b0000001011,
    0b0000000111,
	0b1000000111,
    0b0100000111,
    0b0010000111,
    0b0001000111,
    0b0000100111,
    0b0000010111,
    0b0000001111,
	0b1000001111,
    0b0100001111,
    0b0010001111,
    0b0001001111,
    0b0000101111,
    0b0000011111,
	0b1000011111,
    0b0100011111,
    0b0010011111,
    0b0001011111,
    0b0000111111,
	0b1000111111,
    0b0100111111,
    0b0010111111,
    0b0001111111,
	0b1001111111,
    0b0101111111,
    0b0011111111,
	0b1011111111,
    0b0111111111,
	0b1111111111,
    0b0111111111,
    0b1011111111,
    0b0011111111,
    0b0101111111,
    0b1001111111,
    0b0001111111,
    0b0010111111,
    0b0100111111,
    0b1000111111,
    0b0000111111,
    0b0001011111,
    0b0010011111,
    0b0100011111,
    0b1000011111,
    0b0000011111,
    0b0000101111,
    0b0001001111,
    0b0010001111,
    0b0100001111,
    0b1000001111,
    0b0000001111,
    0b0000010111,
    0b0000100111,
    0b0001000111,
    0b0010000111,
    0b0100000111,
    0b1000000111,
    0b0000000111,
    0b0000001011,
    0b0000010011,
    0b0000100011,
    0b0001000011,
    0b0010000011,
    0b0100000011,
    0b1000000011,
	0b0000000011,
    0b0000000101,
    0b0000001001,
    0b0000010001,
    0b0000100001,
    0b0001000001,
    0b0010000001,
    0b0100000001,
    0b1000000001,
    0b0000000001,
    0b0000000010,
    0b0000000100,
    0b0000001000,
    0b0000010000,
    0b0000100000,
    0b0001000000,
    0b0010000000,
    0b0100000000,
	0b1000000000,
	0b0000000000
};
int pattern13[] = {
    0b0000000001,
    0b0000000010,
    0b0000000100,
    0b0000001000,
    0b0000010000,
    0b0000100000,
    0b0001000000,
    0b0010000000,
    0b0100000000,
    0b1000000000,
    0b1000000001,
    0b1000000010,
    0b1000000100,
    0b1000001000,
    0b1000010000,
    0b1000100000,
    0b1001000000,
    0b1010000000,
    0b1100000001,
    0b1100000010,
    0b1100000100,
    0b1100001000,
    0b1100010000,
    0b1100100000,
    0b1101000000,
    0b1110000000,
    0b1110000001,
    0b1110000010,
    0b1110000100,
    0b1110001000,
    0b1110010000,
    0b1110100000,
    0b1111000000,
    0b1111000001,
    0b1111000010,
    0b1111000100,
    0b1111001000,
    0b1111010000,
    0b1111100000,
    0b1111100001,
    0b1111100010,
    0b1111100100,
    0b1111101000,
    0b1111110000,
    0b1111110001,
    0b1111110010,
    0b1111110100,
    0b1111111000,
    0b1111111001,
    0b1111111010,
    0b1111111100,
    0b1111111101,
    0b1111111110,
    0b1111111111,
	0b1111111110,
	0b1111111101,
	0b1111111100,
    0b1111111010,
    0b1111111001,
	0b1111111000,
    0b1111110100,
    0b1111110010,
    0b1111110001,
	0b1111110000,
    0b1111101000,
    0b1111100100,
    0b1111100010,
    0b1111100001,
	0b1111100000,
    0b1111010000,
    0b1111001000,
    0b1111000100,
    0b1111000010,
    0b1111000001,
	0b1111000000,
    0b1110100000,
    0b1110010000,
    0b1110001000,
    0b1110000100,
	0b1110000010,
	0b1110000001,
    0b1110000000,
    0b1101000000,
    0b1100100000,
    0b1100010000,
    0b1100001000,
    0b1100000100,
    0b1100000010,
    0b1100000001,
    0b1100000000,
    0b1010000000,
    0b1001000000,
    0b1000100000,
    0b1000010000,
    0b1000001000,
    0b1000000100,
    0b1000000010,
    0b1000000001,
	0b1000000000,
	0b0100000000,
	0b0010000000,
	0b0001000000,
	0b0000100000,
	0b0000010000,
	0b0000001000,
	0b0000000100,
	0b0000000010,
	0b0000000001,
	0b0000000000
};

int* Patterns[] = { pattern1, pattern2, pattern3, pattern4, pattern5, pattern6, pattern7, pattern8, pattern9, pattern10, pattern11, pattern12, pattern13};
int PatternL[] = { 19, 19, 4, 19, 19, 10, 63, 63, 10, 63, 63, 109, 109};
int Reps[]= {1,1,8,1,1,5,1,1,5,1,1,1,1};



#endif /* PATTERNS_H_ */

Zdrojový kód: Bariš_Andrej_74HC595.zip

Overenie

Funkčnost nášho zariadenia sme si overili sledovaním LED displeja, na ktorom sme pozorovali správnosť vyobrazených vzorov.


Zapojenie s 74HC595.

Video:

Zdroj: „https://senzor.robotika.sk/sensorwiki/index.php?title=Bežiace_svetlo_s_obvodom_74HC595&oldid=18069“