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

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

ISR (TIMER0_OVF_vect)
{
   uint8_t Number=0;
   TCNT0=0x83;      //значение для T0_0VF переполнения 1 раз в MS
   TIMER.MS++;      //Подсчет MS

    for (Number=0;Number<AMOUNT_TIMERS;Number++) {
   if ((TIMER.Channel[Number].TimeCountingON == TIMER.MS) && (TIMER.Channel[Number].FlagTimersOFF==0)) {
      TIMER.Channel[Number].FlagTimersON = 1;  
   } 

   if ((TIMER.Channel[Number].TimeCountingOFF == TIMER.MS) && (TIMER.Channel[Number].FlagTimersON==1)) {
      TIMER.Channel[Number].FlagTimersOFF = 1;
      TIMER.Channel[Number].FlagTimersON = 0;  
   } 
   }


}

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

		if (TIMER.Channel[0].FlagTimersON == 1) {
			PORTC |= (1<<1);		
		} else PORTC &= ~(1<<1);
		
		if (TIMER.Channel[1].FlagTimersON == 1) {
			PORTC |= (1<<2);		
		} else PORTC &= ~(1<<2);
		
		if (TIMER.Channel[2].FlagTimersON == 1) {
			PORTC |= (1<<3);		
		} else PORTC &= ~(1<<3);		

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

#define F_CPU 8000000UL

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

#define SPI_PORT PORTB
#define SPI_DDR DDRB

#define SPI_MISO PB4
#define SPI_MOSI PB3
#define SPI_SCK PB5
#define SPI_SS PB2	

struct UnionBits
{
	unsigned DO0: 1;
	unsigned DO1: 1;
	unsigned DO2: 1;
	unsigned DO3: 1;
	unsigned DO4: 1;
	unsigned DO5: 1;
	unsigned DO6: 1;
	unsigned DO7: 1;
};

union Byte {
	uint8_t ByteRegister;
	struct UnionBits Register;
};

union Byte OneOUT;
union Byte TwoOUT;
union Byte ThreeOUT;
union Byte OneIN;
union Byte TwoIN;
union Byte ThreeIN;
union Byte FourIN;
union Byte FifthIN;

#define AMOUNT_TIMERS 6		//Количество используемых таймеров
typedef struct 
{
	uint8_t FlagTimersON;		//Флаг работы таймера
	uint8_t FlagTimersOFF;
	volatile uint32_t TimeCountingON;	//Переменная фиксирующая время старта
	volatile uint32_t TimeCountingOFF;
}TimerStruct;

typedef struct 
{
	TimerStruct Channel[AMOUNT_TIMERS];
	volatile uint32_t MS;
	volatile uint32_t TimeCurrent;	//Текущие время
}SoftTimers;
SoftTimers TIMER;
/*Функция инициализации таймеров (установка всех значений в 0 )*/
void InitTimers()
{
	TIMER.TimeCurrent=0;
	TIMER.MS=0;
	for(uint8_t i=0;i<AMOUNT_TIMERS;i++)
	{
		TIMER.Channel[i].FlagTimersON=0;
		TIMER.Channel[i].FlagTimersOFF=0;
		TIMER.Channel[i].TimeCountingON=0;
	}
}
#define MAX_UINT32 4294967295UL
ISR (TIMER0_OVF_vect)
{
	TCNT0=131;		//значение для T0_0VF переполнения 1 раз в MS
	TIMER.MS++;		//Подсчет MS
	if (TIMER.MS == MAX_UINT32)
	{
		TIMER.MS=0;
	}
}
/*Функция вернет TRUE через время TimeVar,Иначе возвращает  CurrentFlag */
uint8_t OnAfterTimeMS(uint32_t TimeVar,uint8_t Number,uint8_t CurrentFlag)
{
	cli();
	uint8_t OutFlag=CurrentFlag;						//Переменная отвечает за RETURN f().
	TIMER.TimeCurrent=TIMER.MS;				//Присваиваем текущие значение МС
	if (TIMER.Channel[Number].FlagTimersON==0)	//Условия для захвата времени вызова функции, и установки флага работы
	{
		TIMER.Channel[Number].TimeCountingON=TIMER.MS;
		TIMER.Channel[Number].FlagTimersON=1;
	}
	volatile uint32_t TimerToStart = TIMER.TimeCurrent-TIMER.Channel[Number].TimeCountingON;
	//Если (время до старта == TimeVar) и (условия по переполнению MAX_UINT32 выполняеться), 
	//то OutFlag=1 и обнуляем Флаг работы
	if ((TimerToStart >= TimeVar)&&((MAX_UINT32-TIMER.Channel[Number].TimeCountingON)>TimeVar))
	{
		OutFlag=1;
		TIMER.Channel[Number].FlagTimersON=0;
		TIMER.Channel[Number].TimeCountingON=0;
		TimerToStart=0;
	}
	else
	{
		OutFlag=CurrentFlag;
		//Если MAX_UINT32 переполниться быстрей чем досчитает TimeVar то обнулим таймер
		if (((MAX_UINT32-TIMER.Channel[Number].TimeCountingON)<TimeVar))
		{
			TIMER.MS=0;
			TIMER.Channel[Number].TimeCountingON=0;
		}
	}
	sei();
	return OutFlag;
}

uint8_t OFFAfterTimeMS(uint32_t TimeVar,uint8_t Number,uint8_t CurrentFlag)
{
	cli();
	uint8_t OutFlag=CurrentFlag;						//Переменная отвечает за RETURN f().
	TIMER.TimeCurrent=TIMER.MS;				//Присваиваем текущие значение МС
	if (TIMER.Channel[Number].FlagTimersOFF==0)	//Условия для захвата времени вызова функции и установки флага работы
	{
		TIMER.Channel[Number].TimeCountingOFF=TIMER.MS;
		TIMER.Channel[Number].FlagTimersOFF=1;
	}
	volatile uint32_t TimerToSTOP = TIMER.TimeCurrent-TIMER.Channel[Number].TimeCountingOFF;
	//Если (время до старта == TimeVar) и (условия по переполнению MAX_UINT32 выполняеться), 
	//то OutFlag=0 и обнуляем Флаг работы
	if ((TimerToSTOP >= TimeVar)&&((MAX_UINT32-TIMER.Channel[Number].TimeCountingOFF)>TimeVar))
	{
		OutFlag=0;
		TIMER.Channel[Number].FlagTimersOFF=0;
		TIMER.Channel[Number].TimeCountingOFF=0;
		TimerToSTOP=0;
	}
	else
	{
		OutFlag=CurrentFlag;
		//Если MAX_UINT32 переполниться быстрей чем досчитает TimeVar то обнулим таймер
		if (((MAX_UINT32-TIMER.Channel[Number].TimeCountingOFF)<TimeVar))
		{
			TIMER.MS=0;
			TIMER.Channel[Number].TimeCountingOFF=0;
		}
	}
	sei();
	return OutFlag;
}

void StartInitIO()
{
	OneOUT.ByteRegister=0x00;
	TwoOUT.ByteRegister=0x00;
	ThreeOUT.ByteRegister=0x00;
	OneIN.ByteRegister=0x00;
	TwoIN.ByteRegister=0x00;
	ThreeIN.ByteRegister=0x00;
	FourIN.ByteRegister=0x00;
	FifthIN.ByteRegister=0x00;
}

/*инициализация SPI модуля в режиме master*/
void SPI_Init(void)
{
   /*настройка портов ввода-вывода
   все выводы, кроме MISO выходы*/
   SPI_DDR |= (1<<SPI_MOSI)|(1<<SPI_SCK)|(1<<SPI_SS)|(0<<SPI_MISO);
   SPI_PORT |= (1<<SPI_MOSI)|(1<<SPI_SCK)|(1<<SPI_SS)|(1<<SPI_MISO);
   SPCR = (1<<SPE)|(0<<DORD)|(1<<MSTR)|(0<<CPOL)|(0<<CPHA)|(0<<SPR1)|(1<<SPR0);
   SPSR = (0<<SPI2X);
}
uint8_t SPI_UpdataByte(uint8_t data)
{
	uint8_t report;
	SPDR = data;
	while(!(SPSR & (1<<SPIF)));
	report = SPDR;
	return report;
}
void SpiOutRegister()
{
	SPI_PORT &= ~(1<<SPI_SS);
	OneIN.ByteRegister=SPI_UpdataByte(0);
	TwoIN.ByteRegister=SPI_UpdataByte(0);
	ThreeIN.ByteRegister=SPI_UpdataByte(ThreeOUT.ByteRegister);
	FourIN.ByteRegister=SPI_UpdataByte(TwoOUT.ByteRegister);
	FifthIN.ByteRegister=SPI_UpdataByte(OneOUT.ByteRegister);
	SPI_PORT |= (1<<SPI_SS);
}
/*Описание распределителей*/
#define R01TOP	OneOUT.Register.DO0
#define R01DOWN OneOUT.Register.DO1
#define R02RO3	OneOUT.Register.DO2
#define R04		OneOUT.Register.DO3
#define R05		OneOUT.Register.DO4
#define R06RO7	OneOUT.Register.DO5
#define R08		OneOUT.Register.DO6
#define RO9		OneOUT.Register.DO7

#define R10 TwoOUT.Register.DO0
#define R11 TwoOUT.Register.DO1
#define R12 TwoOUT.Register.DO2
#define R13 TwoOUT.Register.DO3
#define R14 TwoOUT.Register.DO4
#define R15 TwoOUT.Register.DO5
#define R16 TwoOUT.Register.DO6
#define K1	TwoOUT.Register.DO7

#define K2	ThreeOUT.Register.DO1

/*Описание датчиков*/
#define D01 OneIN.Register.DO0
#define D02 OneIN.Register.DO1
#define D03 OneIN.Register.DO2
//#define D33 OneIN.Register.DO2

void Algoritm()
{
	R01TOP=OnAfterTimeMS(1200,1,R01TOP);
	R01TOP=OFFAfterTimeMS(1300,2,R01TOP);
}

int main(void)
{
	SPI_Init();
	StartInitIO();
	InitTimers();
	DDRD=0xff;// Настраиваем порт D на выход
	TCCR0=(1<<CS01)|(1<<CS00); //Настраиваем пред делитель 64
	TIMSK=(1<<TOIE0); // Запускаем таймер
	TCNT0=131;
	//TIMER.MS=MAX_UINT32-9000;
	sei();
	while(1)
	{
		SpiOutRegister();
		Algoritm();
	}
	return 0;
}

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

typedef struct _soft_timer_t {
    uint32_t start;
    uint32_t timeout;
} soft_timer_t;

/*
 * Включение таймера
 * ~~~~~~~~~~~~~~~~~
 * ВНИМАНИЕ! Если таймер включен, он перезапускается
 */
void soft_timer_arm (soft_timer_t *t, uint32_t timeout)
{
    t->timeout = timeout;
    if (timeout)
        t->start = get_current_tick ();
}
bool_t soft_timer_armed (soft_timer_t *t)
{
    return (t->timeout != 0);
}
bool_t soft_timer_expired (soft_timer_t *t)
{
    uint32_t now;
    if (! soft_timer_armed (t))
        return 0;    /* таймер не запущен, соответственно истекшим быть не может */

    now = get_current_tick ();
    return (now - t->start) >= t->timeout;
}