Форум РадиоКот

Код: Выделить всё

//**********************************************************************************************************************************
                                              //     НАЧАЛО ФАЙЛОВОЙ ИНИЦИАЛИЗАЦИИ     //

#define F_CPU 8000000UL

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

//**********************************************************************************************************************************
                                              //     ОСНОВНЫЕ ПЕРЕМЕННЫЕ     //

// Если надо добавить точку, то пиши для ВКЛ data[1]=codes[res]^0x04;  для ВЫКЛ data[1]=codes[res]|4;
short int k = 0; 

volatile int h = 21, m = 35, s = 0, ms = 0; // тут был unsignet. Это ошибка. Поправил 

//**********************************************************************************************************************************
                                              //     ОСНОВНЫЕ МАССИВЫ ДЛЯ ВЫВОДА     //

const unsigned char codes[10]={0x14,0xD7,0x4C,0x45,0x87,0x25,0x24,0x57,0x4,0x5}; // 0-1-2-3-4-5-6-7-8-9
unsigned char counter[4]={0x08,0x04,0x02,0x01};  // 0b 0000 1111 то, есть это 8+4+2+1 // для счетчика разрядов семисегментника порта С
unsigned char data[4]={0x14,0x14,0x14,0x14};     // для значений, выводимых на дисплей... По умолчанию Err_t ТУТ {0x2C,0xEE,0xEE,0xAC}

//**********************************************************************************************************************************
                                            //    ОКОНЧАТЕЛЬНЫЙ ВАРИАНТ ПРЕРЫВАНИЯ T0    //
											  
											  
ISR(TIMER0_OVF_vect)
{
	TCNT0 = 0x7D;           // Прерывание будет вызываться через 1 мс. Стандартный вариант для 8МГц/64. 125000/125=1000 Гц (1мс)

	                        // считаем от нуля до трех. Переключаем разряд и снова ВКЛЮЧАЕМ.
	(k == 3) ? k = 0 : k++; // Если k достигла трёх, k сбрасываем, иначе k + 1 при каждом вхождении
	PORTC = counter[k];     // Просто включаем аноды сигментника по очереди.
	PORTD = data[k];        // При каждом вхождении выводим битную маску в порт по адресам портов 0,1,2,3.
	
	//   ТАЙМЕРЫ: ТИКАЕМ 1000... ВХОЖДЕНИЙ. ПОСЛЕ ПОДНИМАЕМ ФЛАГ КАЖДЫЙ ПЕРИОД    //
	
	if (++ms > 1000)    // Тактирование каждую миллисекунду и Если насчитали 1000 мс, то считаем мы получили период = 1 секунде!
	{
		ms = 0;
		s++;   
		    if (s==60)
		    {
		        s=0;
		        m--;	
		        if ( m < 0)
		            {
		                if (h>0)
		                 {
			                 h--;
					 m=59;
			                
		                 }
		            }
		
			}
				
	 }
	 
		
}

//**********************************************************************************************************************************
//**********************************************************************************************************************************
                                              //    ОСНОВНЫЕ ФУНКЦИИ ПРОГРАММЫ    //

void init_timer (void)
{
	
	TIMSK0 = (1<<TOIE0);
	TCCR0B = (0<<CS02)|(1<<CS01)|(1<<CS00) ; //8.000.000/64 = 125.000 тиков в сек. (0-1-1 - делитель на 64)
	
}

//**********************************************************************************************************************************
//**********************************************************************************************************************************
//*************************    ДАННЫЙ КУСОК КОДА СЧИТАЕТ КОЛИЧЕСТВО СЕКУНД В ДЕСЯТИЧНОМ ФОРМАТЕ    *********************************
//**********************************************************************************************************************************  
//**********************************************************************************************************************************  

void convert_data_desimal ()                                                                                                   
{
  //Весь вывод идет через data[х]
  unsigned int temp,res;
  //++s;
  temp = s;
  
  res = temp/1000;
  data[0]=codes[res];
  temp=temp-res*1000;
  
  res = temp/100;
  if (s % 2)
  {data[1]=codes[res]^4;
  }
  else
  {data[1]=codes[res]|4;
  }
  temp=temp-res*100;
                       //маленькое вскрытие кода =))
  res = temp/10;       // res=1, temp=10
  data[2]=codes[res];  // вывод на дисплей 1 из массива codes...
  temp=temp-res*10;    // (1*10)-10=0 вот такия пирожки.
  
  data[3]=codes[temp];

}

//**********************************************************************************************************************************
                                              //    ИНИЦИАЛИЗАЦИЯ УСТРОЙСТВ ПРОГРАММЫ    //

int main (void)
{
	cli();
	DDRC = 0x0f;                // готовим порты: PortD - data PortC - anode
	DDRD = 0xff;
	PORTD = 0;
	
	init_timer ();             // готовим таймер/счетчик 0
	
	sei ();                    // Разрешить общие прерыввания. Можно еще написать по старинке SREG |= (1 << 7); 
	
//**********************************************************************************************************************************
                                              //        ГЛАВНЫЙ ЦИКЛ ПРОГРАММЫ        //	
	
	while(1)          
	{
		convert_data_desimal(s);
	}
	
}

Код: Выделить всё

if (h>0)
         {
	  h--;
	  m=59;
	  h = (h*100)+m;
         }

Код: Выделить всё

											  											  
ISR(TIMER0_OVF_vect) 
{
	TCNT0 = 0x7D;           // Прерывание будет вызываться через 1 мс. Стандартный вариант для 8МГц/64. 125000/125=1000 Гц (1мс)
    PORTC=0x0f; 
	                        // считаем от нуля до трех. Переключаем разряд и снова ВКЛЮЧАЕМ.
	(k == 3) ? k = 0 : k++; // Если k достигла трёх, k сбрасываем, иначе k + 1 при каждом вхождении
	PORTC = counter[k];     // Просто включаем аноды сигментника по очереди.
	PORTD = data[k];        // При каждом вхождении выводим битную маску в порт по адресам портов 0,1,2,3.
		
    //   ТАЙМЕРЫ: ТИКАЕМ 1000... ВХОЖДЕНИЙ. ПОСЛЕ ПОДНИМАЕМ ФЛАГ КАЖДЫЙ ПЕРИОД    //
	if (++ms > 1000)
	{
         ms = 0;
		 flag_sec = 1;
    }

}

Код: Выделить всё

												 
void countdown_timer_data_out()   // ФУНКЦИЯ ОТСЧЕТА ВРЕМЕНИ И АРИФМЕТИЧЕСКОГО ПРЕОБРРАЗОВАНИЯ С ВЫВОДОМ НА СЕМИСЕГМЕНТНИК 
{

if (flag_sec == 1)
{

s--;
if (s==0 && m==0 && h==0 )
{
	alarm_flag = 0; //время истекло и мы делаем че надо
	
}
else if (s < 0)
{
	s=59;
	m--;
	if (m < 0)
	{
		m=59;
		h--;
	}
}
flag_sec = 0;
}
//Вывод на дисплей. Арифметика...
seconds_to_go = (((h*60)+m)*60)+s;
h = seconds_to_go / (60*60);
m =(seconds_to_go-(h*60*60))/60;
s = seconds_to_go % 60;
if (h==0)
   {

data[0]=codes[m/10];
data[1]=codes[m%10];
data[2]=codes[s/10];
data[3]=codes[s%10];
   }
else 
   {
	data[0]=codes[h/10];
	data[1]=codes[h%10];
	data[2]=codes[m/10];
	data[3]=codes[m%10];
   }
}

Код: Выделить всё

// Перевод числа в binary-decimal формат
int8_t dec2bindec(int8_t num)
{
	return ((num / 10) << 4) + (num % 10);
}

void show(int8_t dig32, int8_t dig10)
{
	dig32 = dec2bindec (dig32);
	dig10 = dec2bindec (dig10);

	ind[0] = num[dig10 & 0x0F];
	ind[1] = num[dig10 >> 4];

	ind[2] = num[dig32 & 0x0F];
	ind[3] = num[dig32 >> 4];