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

Verzia z 09:09, 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/

Literatúra:

Arduino UNO v3 - datasheet
Posuvný register 74HC595 - datasheet
LED displej BL-AR10Z2510 - datasheet
Odporová sieť 4600X - datasheet

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.

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.

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

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

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 → D5

RCLK → D4

SCLK → D3

SRCLR → D2

OE → GND

LED 9 a 10 → D0 a D1

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.

AVR C-codePATTERNS.h

#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.

Video:

@@ Riadok 61: / Riadok 61: @@
 === 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.
+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.