Operácie

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

Zo stránky SensorWiki

← Predchádzajúca úpravaĎalšia úprava →
StudentMIPS (diskusia | príspevky)
sensor
2 676 editací
StudentMIPS (diskusia | príspevky)
sensor
2 676 editací
Riadok 40: Riadok 40:
[[Súbor:KOND_REAL.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]
[[Súbor:KOND_REAL.jpg|400px|thumb|center|Celkový pohľad na zariadenie.]]


Vcc a GND → z napájania ArduinaNa ovládanie celého systému sme použili mikrokontrolér (napr. Arduino Uno). Zapojenie jednotlivých pinov je nasledovné:
Na ovládanie celého systému sme použili mikrokontrolér Arduino UNO. Zapojenie jednotlivých pinov je nasledovné:
 
Vcc a GND → z napájania Arduina


SER → D2
SER → D2
Riadok 51: Riadok 53:


[[Súbor:Schema zapojenia.drawio.png|600px|thumb|center|Schéma zapojenia LED a odporov s registrom 74HC595.]]
[[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 budú zosynchronizované s tými v shift registri) a "OutSer" (Zabazpečuje prenos dát do posúvneho 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 loope.
Výpis kódu je nižšie...




<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|zdrojaky.zip]]
 
Zdrojový kód: [[Médiá:projektMenoPriezvisko.zip|zdrojaky.zip]]


=== Overenie ===
=== Overenie ===

Verzia z 03:22, 13. jún 2025

Záverečný projekt predmetu MIPS / LS2025 - Meno Priezvisko


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é:

Vcc a GND → z napájania Arduina

SER → D2

SCLK → D3

RCLK → D4

LED 9 a 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 budú zosynchronizované s tými v shift registri) a "OutSer" (Zabazpečuje prenos dát do posúvneho 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 loope. 


#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: zdrojaky.zip

Overenie

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


Aplikácia.

Video:

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