soubor STOPKY.c

#include <avr/io.h>
#include <avr/interrupt.h>
#include "STOPKY_LIB.h"

//#define F_CPU 19660800UL // 19,660800 MHz

#define DesMIN	PB4
#define JedMIN	PB5
#define DesSEC	PB6
#define JedSEC	PB7

#define LEDdot	PB1

#define SETin	PB0	
#define STARTin	PB2
#define TEPLin	PD2


// definice promennych

char LED, MAJAKout, SET_flag,START_DEKR,SETend,STARTold,SETold,NEW_1sec,NEW_05sec;
char Zakaz_DEKREMENTACE,SEC05, DIVIDER;


// Timer Compare Match ISR
SIGNAL(SIG_TIMER1_COMPA)
{
		TIMER_int();
}

int main (void)
{

		DIVIDER = Deleni;				// Pocet interruptu co 10ms pro akci co 1 sec
		INIT_CPU();

// Inicializace promennych
		POZICE_CNT = 4;
		Zakaz_DEKREMENTACE = true;
		MAJAKout    = false;
		SET_flag    = true;

// Nacteni predvolby z EEPROM

		LOADtime();

		if((DESITKYminut_SAVE  < 0) || (DESITKYminut_SAVE  > 9)) DESITKYminut_SAVE  = 1;
		if((JEDNOTKYminut_SAVE < 0) || (JEDNOTKYminut_SAVE > 9)) JEDNOTKYminut_SAVE = 0;
		if((DESITKYminut_SAVE == 0) && (JEDNOTKYminut_SAVE ==0))
		{
		DESITKYminut_SAVE  = 1;
		JEDNOTKYminut_SAVE = 0;
		}

		DESITKYminut   = DESITKYminut_SAVE;
		JEDNOTKYminut  = JEDNOTKYminut_SAVE;
		DESITKYsekund  = 0;
		JEDNOTKYsekund = 0;

// Spusteni zobrazovani
		sei();


while(1)
{

// Test na spusteni dekrementace, sledovani nabezne hrany
		if(NEW_sec)
		{
			cli();
			NEW_sec   = false;
			NEW_1sec  = true;
			sei();
		}

		if(SEC05)
		{
			cli();
			SEC05      = false;
			NEW_05sec  = true;
			sei();
		}

		if(STARTin ^ STARTold)
		{
				if(STARTin) Zakaz_DEKREMENTACE = true; // Konec dekrementace od signalu START
				else
				{
					START_DEKR     = true;		// Nastaveni priznaku spusteni odpoctu casu
					DESITKYminut   = DESITKYminut_SAVE;
					JEDNOTKYminut  = JEDNOTKYminut_SAVE;
					DESITKYsekund  = 0;
					JEDNOTKYsekund = 0; 
					Zakaz_DEKREMENTACE    = false;		// Zruseni zakazu citani	
				}
		}

		if(SETin ^ SETold)
		{
				if(SETin) SETend = true; 		// Nastaveni priznaku ukonceni predvolby
		}

		if(!Zakaz_DEKREMENTACE && NEW_1sec) TIME_DEKREMENT();

		if(NEW_05sec)
		{
			LED = ~LED;
			SET_flag = true;
		}

		if(Zakaz_DEKREMENTACE)
		{
			if(SETend)
			{
				SAVEtime();
				SETend = false;
			}
			else
			{
				if(!SETin && SET_flag)
				{
					DESITKYsekund  = 0;
					JEDNOTKYsekund = 0;
					SET_DEKREMENT();
				}
			}

		}

		NEW_05sec  = false;
		NEW_1sec   = false;
		SET_flag   = false;

}

return (0);

}





soubor STOPKY_LIB.h

extern unsigned char VyberCISLICE,POZICE_CNT;
extern signed char DESITKYminut,JEDNOTKYminut,DESITKYsekund,JEDNOTKYsekund;
extern signed char DESITKYminut_SAVE,JEDNOTKYminut_SAVE,NEW_sec;

extern char LED, MAJAKout, SET_flag,START_DEKR,SETend,STARTold,SETold,NEW_1sec,NEW_05sec;
extern char Zakaz_DEKREMENTACE,SEC05,DIVIDER;

void LOADtime(void);
void SAVEtime(void);
void REFRESH_LED(void);
void INIT_CPU(void);
void SET_DEKREMENT(void);
void TIME_DEKREMENT(void);
void TIMER_int(void);
void bitSet  (char var, char mask);
void bitClear(char var, char mask);


#define true  0xFF
#define false 0
#define Deleni 200

#define	SAVEaddr	0		// Pocatecni adresa v EEPROM



soubor STOPKY_LIB.c

#include "STOPKY_LIB.h"
#include <avr/io.h>
#include <avr/interrupt.h>

unsigned char VyberCISLICE,POZICE_CNT;
signed char DESITKYminut,JEDNOTKYminut,DESITKYsekund,JEDNOTKYsekund;
signed char DESITKYminut_SAVE,JEDNOTKYminut_SAVE,NEW_sec;



/*************************************************************
 RUTINA bitSet
*************************************************************/
void bitSet  (char var, char mask)
{
 		((var) |=  (1 << (mask)));
}

/*************************************************************
 RUTINA bitClear
*************************************************************/
void bitClear(char var, char mask)
{
 		((var) &= ~(1 << (mask)));
}
/*************************************************************
 RUTINA PRO DEKREMENT CASU
*************************************************************/
void TIME_DEKREMENT(void)
{
		JEDNOTKYsekund--;
		if(JEDNOTKYsekund < 0) JEDNOTKYsekund = 9;

		DESITKYsekund--;
		if(DESITKYsekund  < 0) DESITKYsekund  = 5;

		JEDNOTKYminut--;
		if(JEDNOTKYminut  < 0) JEDNOTKYminut  = 9;

		DESITKYminut--;
		if(DESITKYminut  < 0)
		{
			DESITKYminut   = 0;
			Zakaz_DEKREMENTACE = true;
			DESITKYminut   = DESITKYminut_SAVE;
			JEDNOTKYminut  = JEDNOTKYminut_SAVE;
			DESITKYsekund  = 0;
			JEDNOTKYsekund = 0;
		}
}

/*************************************************************
 RUTINA PRO DEKREMENT CASU PRI NASTAVOVANI PREDVOLBY (jen minuty)
*************************************************************/
void SET_DEKREMENT(void)
{
		JEDNOTKYminut--;
		if(JEDNOTKYminut  < 0) JEDNOTKYminut = 9;

		DESITKYminut--;
		if(DESITKYminut   < 0) DESITKYminut  = 9;
}

/*************************************************************
  RUTINA TIMER1 PRERUSENI
*************************************************************/
void TIMER_int(void)
{
// vektor timer 1 interruptu, vyvolano co 10ms

		DIVIDER--;
		if(DIVIDER == 0)
		{
			DIVIDER = Deleni;
			SEC05   = true;						// Priznak 0,5 sec
			NEW_sec = true;						// Priznak nove sekundy
		}

		if(DIVIDER == (Deleni/2)) SEC05 = true;	// Priznak 0,5 sec		
}
/************************************************************************
 PODPROGRAM PRO VYCTENI FLASHE
************************************************************************/
void INIT_CPU(void)
{

	// Vstupni piny
	bitClear (DDRB,0);
	bitClear (DDRB,2);
	bitClear (DDRD,2);


	// Vystupni piny
	bitSet (DDRB, 1);
	bitSet (DDRB, 3);
	bitSet (DDRB, 4);
	bitSet (DDRB, 5);
	bitSet (DDRB, 6);
	bitSet (DDRB, 7);

	bitSet (DDRD, 0);
	bitSet (DDRD, 1);
	bitSet (DDRD, 3);
	bitSet (DDRD, 4);
	bitSet (DDRD, 5);
	bitSet (DDRD, 6);


	// Initiate Timer
	TCCR1B = _BV(WGM12) | _BV(CS12) | _BV(CS10);	// clk/1024 and Clear on match
	OCR1A = 19660800 / 1024;						// Compare register, 1 sec at 19.6608 MHz
	
	TIMSK = _BV(OCIE1A);							// Enable Compare match interrupt	
}

/************************************************************************
 PODPROGRAM PRO VYCTENI Z EEPROM
************************************************************************/
void LOADtime(void)
{
char cSREG;

		EEAR = SAVEaddr;							// adresa ulozeni nastaveni v EEPROM		

		cSREG = SREG; // uloz SREG

// disable interrupts during timed sequence
		cli();
		EECR |= (1<<EERE);
		DESITKYminut_SAVE  = (EEDR >> 4  );
		JEDNOTKYminut_SAVE = (EEDR & 0x0F);
		SREG = cSREG; 		// obnov SREG (I-bit)

		DESITKYminut  = DESITKYminut_SAVE;
		JEDNOTKYminut = JEDNOTKYminut_SAVE;		
		}

/************************************************************************
 PODPROGRAM PRO ZAPIS PREDVOLBY DO EEPROM
************************************************************************/
void SAVEtime(void)
{
char cSREG;

		DESITKYminut_SAVE  = DESITKYminut;
		JEDNOTKYminut_SAVE = JEDNOTKYminut;

// Cekej na dokonceni predchoziho zapisu do EEPROM
		while(EECR & (1<<EEPE));
		
		EEAR = SAVEaddr;							// adresa ulozeni nastaveni v EEPROM		
		EEDR = ((DESITKYminut_SAVE << 4) || JEDNOTKYminut_SAVE);

		cSREG = SREG; // uloz SREG

		EECR &=	~(1<<EEPM1);
		EECR &=	~(1<<EEPM0);
// disable interrupts during timed sequence
		cli();
		EECR |= (1<<EEMPE); // start EEPROM write
		EECR |= (1<<EEPE);
		SREG = cSREG; 		// obnov SREG (I-bit)
}

/************************************************************************
 PODPROGRAM PRO  OBSLUHU LED DISPLAYE - VYBER a ZOBRAZENI CISLOVKY
************************************************************************/

void REFRESH_LED(void)
{
unsigned char TMP = 0;
unsigned char Maska_portuB = 0;
unsigned char Maska_portuD = 0; 


		PORTB = PORTB && 0xf2;

/* VYPOCET ADRESACE POZICE CISLOVKY LED
	POZICE_CNT: 1 - JEDNOTKY SEKUND
				2 - DESITKY  SEKUND
				3 - JEDNOTKY MINUT
				4 - DESITKY  MINUT
*/


		switch(POZICE_CNT)
		{
		case 4:
				TMP = DESITKYminut;
				Maska_portuB = 0x72;
				// blikani dvojtecky pouze pri dekrementaci, sviti pouze pri desitkach minut
				if(!Zakaz_DEKREMENTACE && LED)	Maska_portuB = Maska_portuB && 0xFD;
				break;

		case 3:
				TMP = JEDNOTKYminut;
				Maska_portuB = 0xb2;
				break;
		case 2:
				TMP = DESITKYsekund;
				Maska_portuB = 0xd2;
				break;
		case 1:
				TMP = JEDNOTKYsekund;
				Maska_portuB = 0xe2;
				break;
		}


		POZICE_CNT--;
		if(POZICE_CNT == 0) POZICE_CNT = 4;


	switch(TMP)
	{
		case 0:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x3b;
			break;	
		}
		case 1:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x02;
			break;
		}
		case 2:
		{
			Maska_portuB = Maska_portuB || 0x00;
			Maska_portuD = 0x5b;
			break;
		}
		case 3:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x4b;
			break;
		}
		case 4:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x62;
			break;
		}
		case 5:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x69;
			break;
		}
		case 6:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x79;
			break;
		}
		case 7:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x03;
			break;
		}
		case 8:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x7b;
			break;
		}
		case 9:
		{
			Maska_portuB = Maska_portuB || 0x08;
			Maska_portuD = 0x6b;
			break;
		}
	}
	PORTB = Maska_portuB;
	PORTD = Maska_portuD;
}