Ср ноя 15, 2017 03:52:41
#define F_CPU 8000000UL
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
volatile uint8_t TEST=10;
#define SPI_PORT PORTB
#define SPI_DDR DDRB
#define SPI_MISO PB4
#define SPI_MOSI PB3
#define SPI_SCK PB5
#define SPI_SS PB2
//настройка параметров работы функций
#define BTN_LOCK_TIME 50 /*время обработки дребезга в милисекундах (10-100)*/
#define BTN_LONG_TIME 2000 /*время фиксации длинного нажатия в милисекундах (1000 - 2500)*/
//настройки портов
/*порт чтения кнопок*/
#define BTN_PORT PORTC
#define BTN_DDR DDRC
#define BTN_PIN PINC
/*пины чтения кнопок*/
#define BTN_LINE_UP (1<<0)
#define BTN_LINE_DN (1<<1)
#define BTN_LINE_POWER (1<<2)
#define BTN_LINE_SW (1<<3)
//глобальные переменные
volatile uint8_t BtnFlags; //байт флагов нажатия кнопки
#define BTN_SHRT_UP (1<<0) /*бит короткого нажатия кнопки up*/
#define BTN_SHRT_DN (1<<1) /*бит короткого нажатия кнопки dn*/
#define BTN_SHRT_POWER (1<<2) /*бит короткого нажатия кнопки POWER */
#define BTN_SHRT_SW (1<<3) /*бит короткого нажатия кнопки SW*/
#define BTN_LONG_UP (1<<4) /*бит длинного нажатия кнопки up*/
#define BTN_LONG_DN (1<<5) /*бит длинного нажатия кнопки dn*/
#define BTN_LONG_SW (1<<6) /*бит короткого нажатия кнопки SW*/
//Функция настройки библиотеки работы с кнопками
void BtnInit (void)
{
BTN_DDR &= ~(BTN_LINE_UP| BTN_LINE_DN| BTN_LINE_POWER|BTN_LINE_SW);//на ввод
BTN_PORT |= (BTN_LINE_UP| BTN_LINE_DN| BTN_LINE_POWER|BTN_LINE_SW);//подтяжка вкл
}
//----------
//Функция чтения данных о нажатии кнопок
char BtnGet (void)
{
cli();
char temp = BtnFlags;
BtnFlags = 0;
sei();
return temp;
}
//----------
//короткое нажатие устанавливает бит BTN_SHRT_X глобальной переменной BtnFlags
//длинное нажатие устанавливает бит BTN_LONG_X глобальной переменной BtnFlags
void BtnExe (void)
{
static unsigned char BtnLockBit; //защелка (защита от дребезга)
static unsigned char BtnLockCoun; //счетчик защелки (защита от дребезга)
static unsigned char BtnLongCoun; //счетчик длинного нажатия
static unsigned char BtnLastState; //последнее состояние кнопок перед отпусканием
char mask = 0;
if (! (BTN_PIN & BTN_LINE_UP)) mask = BTN_SHRT_UP;
if (! (BTN_PIN & BTN_LINE_DN)) mask = BTN_SHRT_DN;
if (! (BTN_PIN & BTN_LINE_POWER)) mask = BTN_SHRT_POWER;
if (! (BTN_PIN & BTN_LINE_SW)) mask = BTN_SHRT_SW;
if (mask){ //опрос состояния кнопки
if (BtnLockCoun < (BTN_LOCK_TIME/10)){ //клавиша нажата
BtnLockCoun++;
return; //защелка еще не дощитала - возврат
}
BtnLastState = mask;
BtnLockBit =1; //нажатие зафиксировано
if (BtnLongCoun >= (BTN_LONG_TIME/10))
return; //возврат, т.к. счетчик длинн нажат досчитал до максимума еще раньше
if (++BtnLongCoun >= (BTN_LONG_TIME/10))
BtnFlags |= (BtnLastState<<4); //счетчик досчитал до максимума - устанавливаем биты длинного нажатия
}
else{ //клавиша отжата
if (BtnLockCoun){
BtnLockCoun --;
return; //защелка еще не обнулилась - возврат
}
if (! BtnLockBit) //СТАТИЧЕСКИЙ ВОЗВРАТ
return;
BtnLockBit =0; //отжатие зафиксировано
if (BtnLongCoun < (BTN_LONG_TIME/10))
BtnFlags |= BtnLastState; //установка бита короткого нажатия
BtnLongCoun = 0; //сброс счетчика длительности нажатия
}
}
/******************************************************************************************************/
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 FourOUT;
union Byte FifthOUT;
union Byte SixOUT;
union Byte SevenOUT;
union Byte EightOUT;
union Byte OneIN;
union Byte TwoIN;
union Byte ThreeIN;
union Byte FourIN;
union Byte FifthIN;
union Byte SixIN;
union Byte SevenIN;
union Byte EightIN;
#define AMOUNT_TIMERS 5 //Количество используемых таймеров
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 SEG_PORT EightOUT.ByteRegister
#define SEGA 0
#define SEGB 1
#define SEGC 2
#define SEGD 3
#define SEGE 4
#define SEGF 5
#define SEGG 6
#define SEGH 7
#define ANOD1 SevenOUT.Register.DO5
#define ANOD2 SevenOUT.Register.DO6
#define ANOD3 SevenOUT.Register.DO7
static void segchar (unsigned char seg)
{
switch (seg)
{
case 0:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 1:
SEG_PORT=(1<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 2:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(1<<SEGC)|(0<<SEGD)|(0<<SEGE)|(1<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 3:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(1<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 4:
SEG_PORT=(1<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 5:
SEG_PORT=(0<<SEGA)|(1<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 6:
SEG_PORT=(0<<SEGA)|(1<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 7:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 8:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 9:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 99: //OFF Все сегменты
SEG_PORT=(1<<SEGA)|(1<<SEGB)|(1<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
}
}
volatile uint8_t data1=0;
volatile uint8_t data2=0;
volatile uint8_t AnodCount=0;
void WriteSegNumber(uint8_t Seg3,uint8_t NeberChar)
{
data1=NeberChar%10;
data2=NeberChar/10;
AnodCount++;
switch (AnodCount)
{
case 1:
segchar(data1);
ANOD2=1;
ANOD3=1;
ANOD1=0;break;
case 2:
segchar(data2);
ANOD1=1;
ANOD3=1;
ANOD2=0;break;
case 3:
segchar(Seg3);
ANOD1=1;
ANOD2=1;
ANOD3=0;
AnodCount = 0;break;
}
}
#define MAX_UINT32 4294967295UL
ISR (TIMER0_OVF_vect)
{
TCNT0=125; //значение для T0_0VF переполнения 1 раз в MS
TIMER.MS++; //Подсчет MS
if (TIMER.MS == MAX_UINT32)
{
TIMER.MS=0;
}
BtnExe();
}
/*Функция вернет 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;
FourOUT.ByteRegister=0x00;
FifthOUT.ByteRegister=0x00;
SixOUT.ByteRegister=0x00;
SevenOUT.ByteRegister=0x00;
EightOUT.ByteRegister=0x00;
OneIN.ByteRegister=0x00;
TwoIN.ByteRegister=0x00;
ThreeIN.ByteRegister=0x00;
FourIN.ByteRegister=0x00;
FifthIN.ByteRegister=0x00;
SixIN.ByteRegister=0x00;
SevenIN.ByteRegister=0x00;
EightIN.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)|(0<<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(EightOUT.ByteRegister);
TwoIN.ByteRegister=SPI_UpdataByte(SevenOUT.ByteRegister);
ThreeIN.ByteRegister=SPI_UpdataByte(SixOUT.ByteRegister);
FourIN.ByteRegister=SPI_UpdataByte(FifthOUT.ByteRegister);
FifthIN.ByteRegister=SPI_UpdataByte(FourOUT.ByteRegister);
SixIN.ByteRegister=SPI_UpdataByte(ThreeOUT.ByteRegister);
SevenIN.ByteRegister=SPI_UpdataByte(TwoOUT.ByteRegister);
EightIN.ByteRegister=SPI_UpdataByte(OneOUT.ByteRegister);
SPI_PORT |= (1<<SPI_SS);
}
void TransmitStatusGerkonToLed()
{
OneOUT.ByteRegister=FourIN.ByteRegister;
TwoOUT.ByteRegister=FifthIN.ByteRegister;
ThreeOUT.ByteRegister=SixIN.ByteRegister;
FourOUT.ByteRegister=SevenIN.ByteRegister;
}
void TransmitStatusTumblerSwToLed()
{
FifthOUT.ByteRegister=OneIN.ByteRegister;
SixOUT.ByteRegister=TwoIN.ByteRegister;
SevenOUT.Register.DO0=ThreeIN.Register.DO0;
SevenOUT.Register.DO1=ThreeIN.Register.DO1;
SevenOUT.Register.DO2=ThreeIN.Register.DO2;
SevenOUT.Register.DO3=ThreeIN.Register.DO3;
SevenOUT.Register.DO4=ThreeIN.Register.DO4;
}
volatile uint8_t flagBtnLnUp=0;
void BtnUpdate(void)
{
char BtnMask = BtnGet ();
if (BtnMask == BTN_SHRT_POWER)
{
}
if ((BtnMask == BTN_SHRT_SW))
{
}
//одиночное нажатие +
if (BtnMask == BTN_SHRT_UP)
{
TEST++;
}
//одиночное нажатие -
if ((BtnMask == BTN_SHRT_DN))
{
TEST--;
}
//Удержание +
if ((BtnMask == BTN_LONG_UP))
{
flagBtnLnUp=1;
}
//Удержание -
if ((BtnMask == BTN_LONG_DN))
{
TEST--;
}
}
void Algoritm()
{
}
void DebugAlgoritm()
{
TransmitStatusTumblerSwToLed();
TransmitStatusGerkonToLed();
}
uint8_t Step=0;
int main(void)
{
SPI_Init();
StartInitIO();
InitTimers();
BtnInit();
DDRD=0xFF;
ANOD1=1;ANOD2=1;ANOD3=1;segchar(99);//Офф 7сег индикация.
TCCR0=(1<<CS01)|(1<<CS00); //Настраиваем пред делитель 64
TIMSK=(1<<TOIE0); // Запускаем таймер
TCNT0=131;
sei();
while(1)
{
Step++;
switch (Step)
{
case 1:
SpiOutRegister();break;
case 2:
WriteSegNumber(3,21);break;
case 3:
DebugAlgoritm();break;
case 4:
BtnUpdate();
Step=0;break;
}
}
return 0;
}
//Функция включения сегментов + кодировка.
#define SEG_PORT EightOUT.ByteRegister
#define SEGA 0
#define SEGB 1
#define SEGC 2
#define SEGD 3
#define SEGE 4
#define SEGF 5
#define SEGG 6
#define SEGH 7
#define ANOD1 SevenOUT.Register.DO5
#define ANOD2 SevenOUT.Register.DO6
#define ANOD3 SevenOUT.Register.DO7
static void segchar (unsigned char seg)
{
switch (seg)
{
case 0:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 1:
SEG_PORT=(1<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 2:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(1<<SEGC)|(0<<SEGD)|(0<<SEGE)|(1<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 3:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(1<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 4:
SEG_PORT=(1<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 5:
SEG_PORT=(0<<SEGA)|(1<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 6:
SEG_PORT=(0<<SEGA)|(1<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 7:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 8:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 9:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 99: //OFF Все сегменты
SEG_PORT=(1<<SEGA)|(1<<SEGB)|(1<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
}
}
volatile uint8_t data1=0;
volatile uint8_t data2=0;
volatile uint8_t AnodCount=0;
void WriteSegNumber(uint8_t Seg3,uint8_t NeberChar)
{
data1=NeberChar%10;
data2=NeberChar/10;
AnodCount++;
switch (AnodCount)
{
case 1:
segchar(data1);
ANOD2=1;
ANOD3=1;
ANOD1=0;break;
case 2:
segchar(data2);
ANOD1=1;
ANOD3=1;
ANOD2=0;break;
case 3:
segchar(Seg3);
ANOD1=1;
ANOD2=1;
ANOD3=0;
AnodCount = 0;break;
}
}
Ср ноя 15, 2017 07:22:10
SEG_PORT=(1<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
Ср ноя 15, 2017 07:48:35
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 EightOUT;
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(EightOUT.ByteRegister);
TwoIN.ByteRegister=SPI_UpdataByte(SevenOUT.ByteRegister);
ThreeIN.ByteRegister=SPI_UpdataByte(SixOUT.ByteRegister);
FourIN.ByteRegister=SPI_UpdataByte(FifthOUT.ByteRegister);
FifthIN.ByteRegister=SPI_UpdataByte(FourOUT.ByteRegister);
SixIN.ByteRegister=SPI_UpdataByte(ThreeOUT.ByteRegister);
SevenIN.ByteRegister=SPI_UpdataByte(TwoOUT.ByteRegister);
EightIN.ByteRegister=SPI_UpdataByte(OneOUT.ByteRegister);
SPI_PORT |= (1<<SPI_SS);
}
Ср ноя 15, 2017 15:57:52
Чт ноя 16, 2017 04:24:36
Чт ноя 16, 2017 15:55:13
Пт ноя 17, 2017 02:46:43
Пт ноя 17, 2017 08:58:49
Вс ноя 19, 2017 13:42:04
все это до фига избыточно (как и многое другое в полном коде).7seg писал(а):#define SEG_PORT EightOUT.ByteRegister
#define SEGA 0
#define SEGB 1
#define SEGC 2
#define SEGD 3
#define SEGE 4
#define SEGF 5
#define SEGG 6
#define SEGH 7
#define ANOD1 SevenOUT.Register.DO5
#define ANOD2 SevenOUT.Register.DO6
#define ANOD3 SevenOUT.Register.DO7
static void segchar (unsigned char seg)
{
switch (seg)
{
case 0:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 1:
SEG_PORT=(1<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 2:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(1<<SEGC)|(0<<SEGD)|(0<<SEGE)|(1<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 3:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(1<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 4:
SEG_PORT=(1<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 5:
SEG_PORT=(0<<SEGA)|(1<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 6:
SEG_PORT=(0<<SEGA)|(1<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 7:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
case 8:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(0<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 9:
SEG_PORT=(0<<SEGA)|(0<<SEGB)|(0<<SEGC)|(0<<SEGD)|(1<<SEGE)|(0<<SEGF)|(0<<SEGG)|(1<<SEGH);break;
case 99: //OFF Все сегменты
SEG_PORT=(1<<SEGA)|(1<<SEGB)|(1<<SEGC)|(1<<SEGD)|(1<<SEGE)|(1<<SEGF)|(1<<SEGG)|(1<<SEGH);break;
}
}
Вс ноя 19, 2017 18:24:58
//==================
#ifndef SEVEN_SEGM_LED_IND_H
#define SEVEN_SEGM_LED_IND_H
#include "seven_segm_led_ind.h"
//==================
//==================
#include "main_def_func.h"
//==================
//==================
//#define __COMMON_METHOD_ONE__
#define __COMMON_METHOD_ZERO__
//#define __SEGMENT_METHOD_ONE__
#define __SEGMENT_METHOD_ZERO__
//==================
//==================
#define IND_1 b00000010 // 1<<1
#define IND_2 b00000100 // 1<<2
#define IND_3 b00001000 // 1<<3
#define IND_4 b00000001 // 1<<0
#ifdef __COMMON_METHOD_ONE__
#define IND_1_MASK IND_1
#define IND_2_MASK IND_2
#define IND_3_MASK IND_3
#define IND_4_MASK IND_4
#endif
#ifdef __COMMON_METHOD_ZERO__
#define IND_1_MASK (0xFF ^ (IND_1))
#define IND_2_MASK (0xFF ^ (IND_2))
#define IND_3_MASK (0xFF ^ (IND_3))
#define IND_4_MASK (0xFF ^ (IND_4))
#endif
//----------
#define SEG_A b00000010 // 1<<1
#define SEG_B b00001000 // 1<<3 // A
#define SEG_C b10000000 // 1<<7 // F B
#define SEG_D b00100000 // 1<<5 // G
#define SEG_E b00010000 // 1<<4 // E C
#define SEG_F b00000100 // 1<<2 // D H
#define SEG_G b00000001 // 1<<0
#define SEG_H b01000000 // 1<<6
//----------
typedef struct tab_char_7_segm_cod_t
{
u08 Char;
u08 seven_segm_cod;
} tab_char_7_segm_cod_t;
extern struct tab_char_7_segm_cod_t __flash tab_char_7_segm_cod [];
//==================
//==================
#define MAX_LED_INDS 4
//==================
//==================
extern u08 dsp_buf [];
void clr_dsp_buf (void);
//==================
//==================
typedef struct index_inds
{
u08 i;
u08 ind;
} index_inds;
//==================
//==================
u08 recod_char_7_segm_cod (u08 data);
void set_proc_7_segm_ind_on (void);
void set_proc_7_segm_ind_off (void);
void proc_7_segm_ind (void);
//==================
//==================
#endif
//==================
//==================
#include "seven_segm_led_ind.h"
//==================
//==================
struct index_inds __flash tab_index_inds [] =
{
{1, IND_2_MASK},
{2, IND_3_MASK},
{3, IND_4_MASK},
{0, IND_1_MASK},
};
struct tab_char_7_segm_cod_t __flash tab_char_7_segm_cod [] =
{
#ifdef __SEGMENT_METHOD_ONE__
{'0', (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F)}, // 0
{'1', (SEG_B | SEG_C)}, // 1
{'2', (SEG_A | SEG_B | SEG_D | SEG_E | SEG_G)}, // 2
{'3', (SEG_A | SEG_B | SEG_C | SEG_D | SEG_G)}, // 3
{'4', (SEG_B | SEG_C | SEG_F | SEG_G)}, // 4
{'5', (SEG_A | SEG_C | SEG_D | SEG_F | SEG_G)}, // 5
{'6', (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)}, // 6
{'7', (SEG_A | SEG_B | SEG_C)}, // 7
{'8', (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)}, // 8
{'9', (SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G)}, // 9
{'A', (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G)}, // 10
{'B', (SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)}, // 11
{'C', (SEG_A | SEG_D | SEG_E | SEG_F)}, // 12
{'D', (SEG_B | SEG_C | SEG_D | SEG_E | SEG_G)}, // 13
{'E', (SEG_A | SEG_D | SEG_E | SEG_F | SEG_G)}, // 14
{'F', (SEG_A | SEG_E | SEG_F | SEG_G)}, // 15
{'G', (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F)}, // 16
{'H', (SEG_B | SEG_C | SEG_E | SEG_F | SEG_G)}, // 17
{'L', (SEG_D | SEG_E | SEG_F)}, // 18
{'N', (SEG_C | SEG_E | SEG_G)}, // 19
{'O', (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F)}, // 20
{'P', (SEG_A | SEG_B | SEG_E | SEG_F | SEG_G)}, // 21
{'П', (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F)}, // 22
{'-', (SEG_G)}, // 23
{' ', 0xFF}, // 24
#endif
#ifdef __SEGMENT_METHOD_ZERO__
{'0', (0xFF ^ (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F))}, // 0
{'1', (0xFF ^ (SEG_B | SEG_C))}, // 1
{'2', (0xFF ^ (SEG_A | SEG_B | SEG_D | SEG_E | SEG_G))}, // 2
{'3', (0xFF ^ (SEG_A | SEG_B | SEG_C | SEG_D | SEG_G))}, // 3
{'4', (0xFF ^ (SEG_B | SEG_C | SEG_F | SEG_G))}, // 4
{'5', (0xFF ^ (SEG_A | SEG_C | SEG_D | SEG_F | SEG_G))}, // 5
{'6', (0xFF ^ (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G))}, // 6
{'7', (0xFF ^ (SEG_A | SEG_B | SEG_C))}, // 7
{'8', (0xFF ^ (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G))}, // 8
{'9', (0xFF ^ (SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G))}, // 9
{'A', (0xFF ^ (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G))}, // 10
{'B', (0xFF ^ (SEG_C | SEG_D | SEG_E | SEG_F | SEG_G))}, // 11
{'C', (0xFF ^ (SEG_A | SEG_D | SEG_E | SEG_F))}, // 12
{'D', (0xFF ^ (SEG_B | SEG_C | SEG_D | SEG_E | SEG_G))}, // 13
{'E', (0xFF ^ (SEG_A | SEG_D | SEG_E | SEG_F | SEG_G))}, // 14
{'F', (0xFF ^ (SEG_A | SEG_E | SEG_F | SEG_G))}, // 15
{'G', (0xFF ^ (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F))}, // 16
{'H', (0xFF ^ (SEG_B | SEG_C | SEG_E | SEG_F | SEG_G))}, // 17
{'L', (0xFF ^ (SEG_D | SEG_E | SEG_F))}, // 18
{'N', (0xFF ^ (SEG_C | SEG_E | SEG_G))}, // 19
{'O', (0xFF ^ (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F))}, // 20
{'P', (0xFF ^ (SEG_A | SEG_B | SEG_E | SEG_F | SEG_G))}, // 21
{'П', (0xFF ^ (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F))}, // 22
{'-', (0xFF ^ (SEG_G))}, // 23
{' ', 0xFF}, // 24
#endif
{0xFF, 0xFF},
};
//==================
//==================
u08 dsp_buf [MAX_LED_INDS];
//----------
// Очистка буфера дисплея.
u08 dsp_buf [MAX_LED_INDS];
void clr_dsp_buf (void)
{
for (u08 i = 0; i < MAX_LED_INDS; i++)
dsp_buf [i] = ' ';
}
//==================
//==================
u08 recod_char_7_segm_cod (u08 data)
{
struct tab_char_7_segm_cod_t __flash *ptr = tab_char_7_segm_cod;
for (; ptr -> Char != 0xFF; ptr++)
{
if (ptr -> Char == data)
return ptr -> seven_segm_cod;
}
return false;
}
//==================
//==================
static u08 _proc_7_segm_ind;
void set_proc_7_segm_ind_on (void)
{
_proc_7_segm_ind = 1;
}
void set_proc_7_segm_ind_off (void)
{
_oe_disable ();
_proc_7_segm_ind = 0;
}
void proc_7_segm_ind (void)
{
static soft_timer ST_PROC_7_SEGM_IND;
static u08 cnt_7_segm_ind;
u08 a;
u08 inds;
u08 segments;
switch (_proc_7_segm_ind)
{
case 0:
break;
case 1:
spi_init ();
cnt_7_segm_ind = 0;
set_soft_timer (ST_PROC_7_SEGM_IND, 1, 1);
_proc_7_segm_ind = 2;
break;
case 2:
if (handle_soft_timer (ST_PROC_7_SEGM_IND))
{
u08 cnt = cnt_7_segm_ind;
cnt_7_segm_ind = tab_index_inds [cnt].i;
inds = tab_index_inds [cnt].ind;
segments = recod_char_7_segm_cod (dsp_buf [cnt_7_segm_ind]);
spi_transf_buf [0] = inds;
a = segments;
if ((get_dp_flag () == true) && (cnt_7_segm_ind == 2))
{
#ifdef __SEGMENT_METHOD_ONE__
a |= SEG_H;
#endif
#ifdef __SEGMENT_METHOD_ZERO__
a &= (0xFF ^ SEG_H);
#endif
}
spi_transf_buf [1] = a;
strob_latch_in ();
for (u08 i = 0; i < SPI_BYTES; i++)
{
spi_transf (i);
spi_receive_buf [i] = SPDR;
}
_oe_disable ();
strob_latch_out ();
_oe_enable ();
}
break;
default:
break;
}
}
//==================
Вс ноя 19, 2017 22:34:29
Пн ноя 20, 2017 03:12:42
Пн ноя 20, 2017 03:14:19
Пн ноя 20, 2017 03:29:43
Пн ноя 20, 2017 06:39:21
Пн ноя 20, 2017 06:49:16
Пн ноя 20, 2017 07:24:57
Пн ноя 20, 2017 08:05:57
Пт ноя 24, 2017 09:41:35
Пт ноя 24, 2017 09:53:05