AVR - LED panel - #4 Program

Koutek AVR -
Napsal uživatel Michal, OK1WMR
Pátek, 08 Duben 2011 07:33
Kompatibiln� zapojen�: LED panel s ATmega8
Ke sta�en�: LED_004.c == LED_004.pdf == LED_004.htm
Untitled
/*
Minule jsme si uk�zali, jak blikat ledkou pomoc� bitov�ho komplementu (~). 
Nyn� bychom se mohli pokusit vytvo?it sv?teln�ho hada. K tomuto �?elu se hod� 
bitov� posun. Jak bylo minule uvedeno, bitov� posun se zapisuje >> nebo <<.
V�sledn� program by tedy mohl vypadat:
*/

#define F_CPU 1000000UL  // 1 MHz (z�kladn� frekvence)

#include <avr/io.h>		//Knihovna vstup? a v�stup? (PORT, DDR)
#include <util/delay.h>	//Knihovna ?ekac�ch funkc�

#define RYCHLOST 10	//Po?et krok? za sekundu	
#define DELKA    3		//D�lka hada (po?et ledek))


int main (void)
{
DDRB = 0b11111111;		//piny 0 - 5 budou v�stupn�
unsigned char n;		//nadefinujeme si prom?nnou "n", kter� bude slou�it 
						//k po?�t�n� opakov�n� cyklu
PORTB = 0;				//zhasneme v�echny ledky. (1=sv�t� a 0=zhasnuto)

for(;;)
	{	//hlavn� smy?ka

	for(n=0;n<(8+DELKA);n++)	//Smy?ka s ur?it�m po?tem opakov�n� 
								//(8 ledek + d�lka hada, aby nevznikal
								//nov� had, dokud ten star� nezmiz� - 
								//m?�ete vyzkou�et, co se stane, kdy� 
								//konstantu DELKA sma�ete.)
		{
		if (n<DELKA)	//pokud je po?et opakov�n� men�� ne� d�lka hada
			{			//mus�me p?idat dal�� ?l�nek hada (rozsv�tit led)
						//asi takto: 00000001, 00000011, 00000111, atd.
			
			PORTB <<=1;	//posuneme hada doleva (bity se posunou doleva a 
						//vpravo se objev� 0.
						//nap?: 00001111 po odrotov�n� do leva: 00011110
			
			PORTB ++;	//p?i?teme 1 (rozsv�t�me dal�� ?l�nek): 
						//00011110 + 1 = 00011111 (hadovi p?ibyl ?l�nek)
			}			
		else			//pokud nen� po?et opakov�n� men�� ne� d�lka hada
			{			//-to znamen�, �e hada u� jsme nakreslili..
			
			PORTB <<=1;	//...tak pouze posuneme doleva 
						//(vpravo se automaticky dopln� nula)
						// nap?: 00111110 (had je zakon?en, a p?�t? u� bude 
						//jen "l�zt": 01111100, 11111000, 11110000, atd.
			}			//jinak by n�m had po?�d p?ir?stal, a� by sv�tily
						//v�echny ledky
		
		_delay_ms (1000/RYCHLOST);	//?ek�n� (1000 ms = 1 sekunda) - rychlost 
									//je tedy po?et krok? za sekundu 
		
		}	//konec t?la cyklu - a znovu na za?�tek :-)
			//a� se cyklus provede 8x (po?et ledek) + po?et ledek na hada 
			//- to znamen�, �e had u� vyleze "mimo ledky" 
			//  (10000000 -> 00000000) - v�echny ledky jsou zhasnut� 
			//- cyklus se ukon?� (provedl se "(8+DELKA)" kr�t)


	}	// konec nekone?n� smy?ky for(;;) program sko?� zp�tky na za?�tek
		// a v�e se opakuje.

} //konec funkce main (sem se sice program nikdy nedostane, ale funkce mus� 
  //b�t ukon?en�, jinak by hl�sil p?eklada? chybu

/*
V tomto programu jsme pou�ili prom?nnou (n), podm�n?n� blok (if) a smy?ku s 
ur?it�m po?tem opakov�n� (for(n=0;n<8;n++)).
*/
/*
PROM?NN�:
Prom?nn� je m�sto v pam?ti mikrokontrol�ru, kam se ukl�daj� ?�sla. Proto�e
mikrokontrol�r pot?ebuje v?d?t, jak velk� kus pam?ti si m� pro danou prom?nnou
vyhradit, p�e se p?i definici prom?nn� jej� typ (modr� text p?ed prom?nnou).
P?ehled typ? prom?nn�ch:

  TYP:		   VELIKOST:	?�SLO, JAK� JE MO�NO UCHOVAT:
char		     8 bit      	   -128   a�    127
unsigned char    8 bit      	      0   a�    255
int             16 bit      	 -32768   a�    32767
unsigned int    16 bit      	      0   a�    65535
long            32 bit   	 -2,14*10^9   a�    2,14*10^9
unsigned long   32 bit       	      0   a�    4,29*10^9
*/

/*
PODM�N?N� BLOK:

if (podm�nka)
	blok1
else
	blok2

Podm�n?n� blok slou�� k v?tven� programu. Pou��v� se tehdy, kdy� pot?ebujeme
prov�st n?jak� p?�kazy jen tehdy, kdy� plat� n?jak� podm�nka.
Podm�nka je v�raz, kter� kdy� je pravdiv�, vykon� se blok1 a kdy� pravdiv�
nen�, vykon� se blok2.
Pokud obsahuje blok1 nebo blok2 v�ce p?�kaz?, uzav�raj� se do slo�en�ch 
z�vorek "{}".
*/
/*
SMY?KA:

for(inicializ�tor;podm�nka;inkrement)
{
t?lo cyklu
}

Inicializ�tor je vlastn? za?�tek (odkud m� cyklus po?�tat)
Podm�nka je v�raz, kter� kdy� plat�, tak cyklus provede dal�� opakov�n�. 
Pokud v�raz p?estane platit, cyklus se ukon?� a program pokra?uje za cyklem.
Inkrement je v�raz, kter� ?�k�, kolik se m� p?i?�st, nebo ode?�st s ka�d�m 
opakov�n�m cyklu. My jsme pou��vali: n++, co� je tot� jako: n=n+1. S ka�d�m
opakov�n�m cyklu se tedy k prom?nn� "n" p?i?te 1. 
T?lo cyklu je sada p?�kaz? uzav?en� do slo�en�ch z�vorek "{}" kter� se p?i
ka�d�m opakov�n� vykon�.

Dejme tomu, �e chceme n?jak� blok instrukc� prov�st 3x.
Nap�eme:
for (n=0;n<3;n++)
{
blok p?�kaz?
}

N� cyklus tedy za?ne: 

n=0. Otestuje podm�nku n<3 = pravda - pokra?uje se. K prom?nn� "n" se 
p?i?te 1 (n++).
A znovu:
n=1 (0+1=1). Podm�nka: n<3 = pravda - pokra?uje se. Op?t se p?i?te 1 (n++).
A zas:
n=2 (1+1=2). Podm�nka: n<3 = pravda - pokra?uje se. Zase se p?i?te 1 (n++).
A nakonec:
n=3 (2+1=2). Podm�nka: n<3 = nepravda - konec cyklu.

Je tedy vid?t, �e se cyklus provedl 3x. 
*/
/*
Nyn� se pod�v�me, co se stalo s registrem PORTB v na�em programu.
Nejprve jsme zhasli v�echny ledky tak, �e jsme do PORTB zapsali sam� nuly 
(0 = 0b00000000).
Pot� jsme vstoupili do hlavn� smy?ky, kter� neust�le spou�t� cyklus:
"for(n=0;n<(8+DELKA);n++)". Jakmile se tento cyklus provede tolikr�t, kolikr�t 
je pot?eba, program "propadne" zp?t do hlavn� smy?ky "for(;;)" kter� jej vr�t�
zp?t na za?�tek cyklu "for(n=0;n<(8+DELKA);n++)"
Hlavn� smy?ka m� tedy jedin� �kol, a to resetovat n� cyklus 
"for(n=0;n<(8+DELKA);n++)".
*/

/*
Na za?�tku programu jsou definov�ny konstanty "RYCHLOST" a "DELKA", kter� 
ur?uj� rychlost pohybu hada a jeho d�lku. Rychlost je d�na po?tem krok? za 
sekundu (1 - 1000) a d�lka je d�na po?tem sv�t�c�ch ledek. (0 - kolik chcete).
*/


//Pro radioklub OK1KVK naspal Va�ek Kr�l