TipsAndTriks/avr/macros.h

////////////////////////////////////////////////////////////////////////////////////////////////////
//	Макроопределения.
//
//  (C) Евгений Трифонов, Денис Железняков. 2001 - 2007 г.
//	Версия: 2.7.1 от 18.12.2007
////////////////////////////////////////////////////////////////////////////////////////////////////

// Параметры генератора (частота генератора указывается в Гц.)
#ifndef __MCU_Clock
  #warning Тактовая частота процессора (__MCU_Clock) не указана! Используется значение по-умолчанию: 9 216 000 Гц
  #define __MCU_Clock   9216000
#endif

//
#ifndef __Macros_Included__
	#define __Macros_Included__

//
#ifndef ENABLE_BIT_DEFINITIONS
	#define ENABLE_BIT_DEFINITIONS
#endif

//
#include <ioavr.h>
#include <ina90.h>

// Циклы
#define Hz(Value)       ((1 / (float)(Value)) * __MCU_Clock)
#define kHz(Value)      Hz((Value) * 0x000003E8)
#define MHz(Value)      Hz((Value) * 0x000F4240)
#define _ns             * ((float)(__MCU_Clock) / 0x3B9ACA00)
#define _us             * ((float)(__MCU_Clock) / 0x000F4240)
#define _mks            _us
#define _ms             * ((float)(__MCU_Clock) / 0x000003E8)
#define _s              * ((float)(__MCU_Clock))
#define _cycle
#define _cycles

// Задержка
#define Delay(Value)            __delay_cycles(Value)
#define Delay_ns(Value) 	      Delay((Value)_ns)
#define Delay_us(Value) 	      Delay((Value)_us)
#define Delay_mks(Value)        Delay((Value)_mks)
#define Delay_ms(Value) 	      Delay((Value)_ms)
#define Delay_s(Value)  	      Delay((Value)_s)
#define Delay_Hz(Value)         Delay(Hz(Value))
#define Delay_kHz(Value) 	      Delay(kHz(Value))
#define Delay_MHz(Value)  	    Delay(MHz(Value))
#define Delay_Cycle(Value)      Delay(Value)
#define Delay_Cycles(Value)	    Delay(Value)

// Таймеры
#define TC16_Compare(Div, Value)      (unsigned  int)((1 / (float)(Div)) * (Value))
#define TC16_Overflow(Div, Value)     (unsigned  int)(0x10000 - TC16_Compare(Div, Value))
#define TC8_Compare(Div, Value)       (unsigned char)TC16_Compare(Div, Value)
#define TC8_Overflow(Div, Value)      (unsigned char)(0x00100 - TC8_Compare(Div, Value))

// Битовые операции
#define Bit(Idx)                  		(1 << (Idx))
#define _Bit(Idx)                 		Bit(Idx)

// Изменение состояния обного бита в переменной или регистре
//
//  Примеры:
//      Set_Bit(TCCR1A, WGM10);       - установка бита WGM10 в регистре TCCR1A
//      Clear_Bit(TCCR1B, CS10);      - сброс бита CS10 в регистре TCCR1B
//      Get_Bit(TCCR1A, WGM10);       - получение значения бита WGM10 в регистре TCCR1A
//      Invert_Bit(TCCR1B, CS10);     - инвертирование бита CS10 в регистре TCCR1B
//      Is_Bit_Set(TCCR1A, WGM10);    - возвращает истину если бит WGM10 в регистре TCCR1A установлен
//      Is_Bit_Clear(TCCR1B, CS10);   - возвращает истину если бит CS10 в регистре TCCR1B сброшен
//
#define Set_Bit(Var, BitIdx)          ((Var) |=  _Bit(BitIdx))
#define Clear_Bit(Var, BitIdx)        ((Var) &= ~_Bit(BitIdx))
#define Get_Bit(Var, BitIdx)          ((Var)  &  _Bit(BitIdx))
#define Invert_Bit(Var, BitIdx)       ((Var) ^=  _Bit(BitIdx))
#define Toggle_Bit(Var, BitIdx)       Invert_Bit(Var, BitIdx)
#define Is_Bit_Set(Var, BitIdx)       (Get_Bit(Var, BitIdx) == _Bit(BitIdx))
#define Is_Bit_Clear(Var, BitIdx)     (Get_Bit(Var, BitIdx) == 0x00)

// Изменение состояния переменной или регистра по указанной маске
//
//  Примеры:
//      Set_Bits(TCCR1A, _Bit(WGM10) | _Bit(COM1A1));      - установка битов WGM10 и COM1A1 в регистре TCCR1A
//      Set_Bits(TCCR1A, ~_Bit(WGM10) | _Bit(COM1A1));     - сброс бита WGM10 и установка бита COM1A1 в регистре TCCR1A
//      Clear_Bits(TCCR1A, ~_Bit(WGM10) | _Bit(COM1A1));   - установка бита WGM10 и сброс бита COM1A1 в регистре TCCR1A
//
#define Set_Bits(Var, Mask)           ((Var) |=  (Mask))
#define Clear_Bits(Var, Mask)         ((Var) &= ~(Mask))
#define Invert_Bits(Var, Mask)        ((Var) ^=  (Mask))
#define Toggle_Bits(Var, Mask)        Invert_Bits(Var, (Mask))

// Изменение состояния обного бита в переменной или регистре посредством определённых флагов (шаблонов)
//
//  Примеры:
//      volatile Byte System_Status = 0x00;       - объявление переменной, где будут меняться флаги
//
//      #define Error_Flag    System_Status, 0    - объявление флага в переменной System_Status в бите 0
//      #define Ready_Flag    System_Status, 1    - объявление флага в переменной System_Status в бите 1
//      #define Delay_Flag    System_Status, 3    - объявление флага в переменной System_Status в бите 3
//      #define RX_Flag       System_Status, 6    - объявление флага в переменной System_Status в бите 6
//      #define TX_Flag       System_Status, 8    - объявление флага в переменной System_Status в бите 8
//
//      Set_Flag(Ready_Flag);         - установка бита 1 в переменной System_Status
//      Set_Flag(RX_Flag);            - установка бита 6 в переменной System_Status
//      Clear_Flag(TX_Flag);          - сброс бита 8 в переменной System_Status
//
#define Set_Flag(FlagDef)           Set_Bit(FlagDef)
#define Clear_Flag(FlagDef)         Clear_Bit(FlagDef)
#define Get_Flag(FlagDef)           Get_Bit(FlagDef)
#define Invert_Flag(FlagDef)        Invert_Bit(FlagDef)
#define Toggle_Flag(FlagDef)        Toggle_Bit(FlagDef)
#define Is_Flag_Set(FlagDef)        Is_Bit_Set(FlagDef)
#define Is_Flag_Clear(FlagDef)      Is_Bit_Clear(FlagDef)

//
#define BIN(Value)    (((0x##Value##L >> 0x0015) & 0x8000) + ((0x##Value##L >> 0x0012) & 0x4000) +\
                       ((0x##Value##L >> 0x000F) & 0x2000) + ((0x##Value##L >> 0x000C) & 0x1000) +\
                       ((0x##Value##L >> 0x0009) & 0x0800) + ((0x##Value##L >> 0x0006) & 0x0400) +\
                       ((0x##Value##L >> 0x0003) & 0x0200) + ((0x##Value##L  & 0x0100)) +\
                       ((0x##Value##L >> 0x0015) & 0x0080) + ((0x##Value##L >> 0x0012) & 0x0040) +\
                       ((0x##Value##L >> 0x000F) & 0x0020) + ((0x##Value##L >> 0x000C) & 0x0010) +\
                       ((0x##Value##L >> 0x0009) & 0x0008) + ((0x##Value##L >> 0x0006) & 0x0004) +\
                       ((0x##Value##L >> 0x0003) & 0x0002) + ((0x##Value##L  & 0x0001)))

// Скорость порта UART
#define Baud_Rate(BaudRate)       (unsigned  int)((unsigned long)(__MCU_Clock) / (((BaudRate) * 0x10L) - 1))
#define Baud_RateL(BaudRate)      (unsigned char)((unsigned long)(__MCU_Clock) / (((BaudRate) * 0x10L) - 1))
#define Baud_RateH(BaudRate)      (unsigned char)((unsigned long)(__MCU_Clock) / (((BaudRate) * 0x10L) - 1) >> 8)

// Переименование типов

#ifndef bool
  #include <stdbool.h>
#endif

// Булевый тип
typedef bool                  Boolean;

// Целый тип, 8 бит
typedef unsigned char				  Byte;
typedef unsigned char				  u08;
typedef signed char				    ShortInt;
typedef signed char				    s08;
typedef signed char				    SByte;

// Целый тип, 16 бит
typedef unsigned int				  Word;
typedef unsigned int				  u16;
typedef unsigned int          UInt16;
typedef signed int            SmallInt;
typedef signed int            s16;
typedef signed int            SInt16;

// Целый тип, 32 бита
typedef unsigned long				  DWord;
typedef unsigned long				  Cardinal;
typedef unsigned long				  u32;
typedef unsigned long         UInt32;
typedef signed long				    Integer;
typedef signed long				    s32;
typedef signed long           SInt32;

// Целый тип, 64 бита
typedef unsigned long long    DDWord;
typedef unsigned long	long	  u64;
typedef unsigned long long    UInt64;
typedef signed long long	    Int64;
typedef signed long	long	    s64;
typedef signed long	long	    SInt64;

// Вещественный тип, 32 бита
typedef float                 Float;

//Вещественный тип, 32 бита (если разрешено в настройках, то 64 бита)
typedef double                Double;
typedef long double           Extended;

//
typedef union
{
	unsigned char Byte;
	struct
	{
		unsigned char
			Bit0: 1,
			Bit1: 1,
			Bit2: 1,
			Bit3: 1,
			Bit4: 1,
			Bit5: 1,
			Bit6: 1,
			Bit7: 1;
	};
} Byte_Bit;

//
typedef union
{
	unsigned int Word;
	struct
	{
		unsigned char Byte0;
		unsigned char Byte1;
	};
	struct
	{
		unsigned int
			Bit0:  1,
			Bit1:  1,
			Bit2:  1,
			Bit3:  1,
			Bit4:  1,
			Bit5:  1,
			Bit6:  1,
			Bit7:  1,
			Bit8:  1,
			Bit9:  1,
			Bit10: 1,
			Bit11: 1,
			Bit12: 1,
			Bit13: 1,
			Bit14: 1,
			Bit15: 1;
	};
} Word_Byte_Bit;

//
typedef union
{
  unsigned int Word;
  struct
  {
		unsigned char Byte0;
		unsigned char Byte1;
	};
} Word_Byte;

//
typedef union
{
  unsigned long DWord;
  struct
  {
		unsigned char Byte0;
		unsigned char Byte1;
		unsigned char Byte2;
		unsigned char Byte3;
	};
} DWord_Byte;

//
typedef union
{
  unsigned long DWord;
  struct
  {
		unsigned char Byte0;
		unsigned char Byte1;
		unsigned char Byte2;
		unsigned char Byte3;
	};
  struct
  {
    unsigned long
			Bit0:  1,
			Bit1:  1,
			Bit2:  1,
			Bit3:  1,
			Bit4:  1,
			Bit5:  1,
			Bit6:  1,
			Bit7:  1,
			Bit8:  1,
			Bit9:  1,
			Bit10: 1,
			Bit11: 1,
			Bit12: 1,
			Bit13: 1,
			Bit14: 1,
			Bit15: 1,
			Bit16: 1,
			Bit17: 1,
			Bit18: 1,
			Bit19: 1,
			Bit20: 1,
			Bit21: 1,
			Bit22: 1,
			Bit23: 1,
			Bit24: 1,
			Bit25: 1,
			Bit26: 1,
			Bit27: 1,
			Bit28: 1,
			Bit29: 1,
			Bit30: 1,
			Bit31: 1;
	};
} DWord_Byte_Bit;

//
typedef union
{
  unsigned long long DDWord;
  struct
  {
		unsigned int Word0;
		unsigned int Word1;
		unsigned int Word2;
		unsigned int Word3;
	};
  struct
  {
    unsigned char Byte0;
    unsigned char Byte1;
    unsigned char Byte2;
    unsigned char Byte3;
    unsigned char Byte4;
    unsigned char Byte5;
		unsigned char Byte6;
		unsigned char Byte7;
	};
} DDWord_Byte;

//
typedef union
{
  unsigned long long DDWord;
  struct
  {
		unsigned int Word0;
		unsigned int Word1;
		unsigned int Word2;
		unsigned int Word3;
	};
  struct
  {
    unsigned char Byte0;
    unsigned char Byte1;
    unsigned char Byte2;
    unsigned char Byte3;
    unsigned char Byte4;
    unsigned char Byte5;
		unsigned char Byte6;
		unsigned char Byte7;
	};
  struct
  {
    unsigned long
			Bit0:  1,
			Bit1:  1,
			Bit2:  1,
			Bit3:  1,
			Bit4:  1,
			Bit5:  1,
			Bit6:  1,
			Bit7:  1,
			Bit8:  1,
			Bit9:  1,
			Bit10: 1,
			Bit11: 1,
			Bit12: 1,
			Bit13: 1,
			Bit14: 1,
			Bit15: 1,
			Bit16: 1,
			Bit17: 1,
			Bit18: 1,
			Bit19: 1,
			Bit20: 1,
			Bit21: 1,
			Bit22: 1,
			Bit23: 1,
			Bit24: 1,
			Bit25: 1,
			Bit26: 1,
			Bit27: 1,
			Bit28: 1,
			Bit29: 1,
			Bit30: 1,
			Bit31: 1,
			Bit32: 1,
			Bit33: 1,
			Bit34: 1,
			Bit35: 1,
			Bit36: 1,
			Bit37: 1,
			Bit38: 1,
			Bit39: 1,
			Bit40: 1,
			Bit41: 1,
			Bit42: 1,
			Bit43: 1,
			Bit44: 1,
			Bit45: 1,
			Bit46: 1,
			Bit47: 1,
			Bit48: 1,
			Bit49: 1,
			Bit50: 1,
			Bit51: 1,
			Bit52: 1,
			Bit53: 1,
			Bit54: 1,
			Bit55: 1,
			Bit56: 1,
			Bit57: 1,
			Bit58: 1,
			Bit59: 1,
			Bit60: 1,
			Bit61: 1,
			Bit62: 1,
			Bit63: 1;
	};
} DDWord_Byte_Bit;


////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  Операции с портами.
//
//  Синтаксис:
//      #define <имя>   <Letter>, <Idx>, [<Level>], [<PullUp>]
//
//      <Letter>  - Буква порта (A, B, C, и т. д.).
//      <Idx>     - Номер вывода порта (0-7).
//      <Level>   - Активный уровень. (High или Low, если не указан, то High);
//                    High - логическая единица;
//                    Low  - логический ноль.
//      <PullUp>  - Внешний подтягивающий резистор. (On или Off, если не указан, то Off);
//                    On  - используется внешний подтягивающий резистор;
//                    Off - внешнего подтягивающего резастора нет.
//
//  Описание макрокоманд:
//      Pin_HiZ (Set_Pin_HiZ)             - если PullUp = Off, то вывода порта устанавливается в "третье" (Hi-Z) состояние;
//      Pin_PullUp_IO (Set_Pin_PullUp_IO) - установка вывода порта для работы с внешним "подтягивающим" резистором;
//      Pin_In (Set_Pin_In)               - установка вывода порта как вход;
//      Pin_Out (Set_Pin_Out)             - установка вывода порта как выход;
//      Pin_On (Set_Pin_On)               - установка активного логического уровня на выводе порта;
//      Pin_High (Set_Pin_High)           - установка "единичного" логического уровня на выводе порта;
//      Pin_Off (Set_Pin_Off)             - установка неактивного логического уровня на выводе порта;
//      Pin_Low (Set_Pin_Low)             - установка "нулевого" логического уровня на выводе порта;
//      Pin_Signal (Get_Pin_Signal)       - проверка логического уровня на выводе порта;
//      Pin_Change (Change_Pin_Signal)    - изменение логического уровня на выводе порта на противоположное;
//      Pin_Invert (Invert_Pin_Signal)    - аналогично Pin_Change;
//      Pin_Out_On (Set_Pin_Out_On)       - установка вывода порта как выход и установка активного логического уровня;
//      Pin_Out_Off (Set_Pin_Out_Off)     - установка вывода порта как выход и установка неактивного логического уровня;
//      Pin_Out_High (Set_Pin_Out_High)   - установка вывода порта как выход и установка единичного логического уровня на выводе порта;
//      Pin_Out_Low (Set_Pin_Out_Low)     - установка вывода порта как выход и установка нулевого логического уровня на выводе порта.
//
//  Примечания:
//      1. Если в определении вывода порта указано, что используется внешний подтягивающий
//         резистор (PullUp = On), то макрокоманды Pin_In и Pin_Out выполняют действия,
//         аналогичные макрокоманде Pin_PullUp_IO.
//      2. В скобках указаны макрокоманды, выполняющие аналогичные действия, но параметры для
//         них передаются не через определение define, а также как в функцию.
//      3. В определении define последние два параметра можно не указывать, но ЗАПЯТЫЕ ОПУСКАТЬ НЕЛЬЗЯ.
//
//  Примеры:
//      #define Example1    B, 5, Low,
//      #define Example2    B, 5,,
//      #define Example3    B, 5, Low, On
//      #define Example4    B, 5,, Off
//
//      Pin_Out(Example1);	- установка вывода 5 порта В на выход;
//      Pin_On(Example1);		- установка указанного активного уровня (Low) на выводе 5 порта B.
//
//  Пример к примечанию 2:
//      Макрокоманда Set_Pin_On(B, 5, Low, On) выполнит аналогичные действия, что и команда Pin_On(Example3)
//
////////////////////////////////////////////////////////////////////////////////////////////////////

// Основные операции с портами
#define Set_PORT_Bit(Ltr, Idx)        (PORT##Ltr |=  _Bit(Idx))
#define Clr_PORT_Bit(Ltr, Idx)        (PORT##Ltr &= ~_Bit(Idx))
#define Invert_PORT_Bit(Ltr, Idx)     (PORT##Ltr ^=  _Bit(Idx))
#define Xor_PORT_Bit(Ltr, Idx)        Invert_PORT_Bit(Ltr, Idx)
#define Toggle_PORT_Bit(Ltr, Idx)     Invert_PORT_Bit(Ltr, Idx)
#define Set_DDR_Bit(Ltr, Idx)         (DDR##Ltr |=  _Bit(Idx))
#define Clr_DDR_Bit(Ltr, Idx)         (DDR##Ltr &= ~_Bit(Idx))
#define Invert_DDR_Bit(Ltr, Idx)      (DDR##Ltr ^=  _Bit(Idx))
#define Xor_DDR_Bit(Ltr, Idx)         Invert_DDR_Bit(Ltr, Idx)
#define Toggle_DDR_Bit(Ltr, Idx)      Invert_DDR_Bit(Ltr, Idx)
#define Get_PIN_State(Ltr, Idx)       (PIN##Ltr  &  _Bit(Idx))

// Установка вывода порта в третье состояние (Hi-Z)
#define Set_Pin_HiZ(Ltr, Idx, Level, PullUp)         { Clr_DDR_Bit(Ltr, Idx); Clr_PORT_Bit(Ltr, Idx); }
#define Pin_HiZ(PortDef)                             Set_Pin_HiZ(PortDef)

// Установка вывода порта для работы с внешним подтягивающим резистором
#define SetPinPullUp(Ltr, Idx)
#define SetPinPullUpOff(Ltr, Idx)
#define SetPinPullUpOn(Ltr, Idx)                     Clr_PORT_Bit(Ltr, Idx)
#define Set_Pin_PullUp_IO(Ltr, Idx, Level, PullUp)   { Clr_DDR_Bit(Ltr, Idx); SetPinPullUp##PullUp(Ltr, Idx); }
#define Pin_PullUp_IO(PortDef)                       Set_Pin_PullUp_IO(PortDef)

// Установка вывода порта как вход
#define Set_Pin_In(Ltr, Idx, Level, PullUp)          Set_Pin_PullUp_IO(Ltr, Idx, Level, PullUp)
#define Pin_In(PortDef)                              Set_Pin_In(PortDef)

// Установка вывода порта как выход
#define SetPinOut(Ltr, Idx)                          Set_DDR_Bit(Ltr, Idx)
#define SetPinOutOff(Ltr, Idx)                       Set_DDR_Bit(Ltr, Idx)
#define SetPinOutOn(Ltr, Idx)                        Clr_DDR_Bit(Ltr, Idx)
#define Set_Pin_Out(Ltr, Idx, Level, PullUp)         { SetPinOut##PullUp(Ltr, Idx); SetPinPullUp##PullUp(Ltr, Idx); }
#define Pin_Out(PortDef)	                           Set_Pin_Out(PortDef)

// Установка активного логического уровня на выводе порта
#define SetPin(Ltr, Idx)                             Set_PORT_Bit(Ltr, Idx)
#define SetPinHighOn(Ltr, Idx)	                     Clr_DDR_Bit(Ltr, Idx)
#define SetPinHighOff(Ltr, Idx)	                     Set_PORT_Bit(Ltr, Idx)
#define SetPinLowOn(Ltr, Idx)	                       Set_DDR_Bit(Ltr, Idx)
#define SetPinLowOff(Ltr, Idx)	                     Clr_PORT_Bit(Ltr, Idx)
#define SetPinHigh(Ltr, Idx)	                       Set_PORT_Bit(Ltr, Idx)
#define SetPinLow(Ltr, Idx)	                         Clr_PORT_Bit(Ltr, Idx)
#define SetPinOn(Ltr, Idx)                           Clr_DDR_Bit(Ltr, Idx)
#define SetPinOff(Ltr, Idx)                          Set_PORT_Bit(Ltr, Idx)
#define Set_Pin_On(Ltr, Idx, Level, PullUp)	         SetPin##Level##PullUp(Ltr, Idx)
#define Pin_On(PortDef)                              Set_Pin_On(PortDef)

// Установка вывода порта как выход и установка активного логического уровня
#define Set_Pin_Out_On(Ltr, Idx, Level, PullUp)      { Set_Pin_Out(Ltr, Idx, Level, PullUp); Set_Pin_On(Ltr, Idx, Level, PullUp); }
#define Pin_Out_On(PortDef)                          Set_Pin_Out_On(PortDef)

// Установка единичного логического уровня на выводе порта
#define Set_Pin_High(Ltr, Idx, Level, PullUp)        Set_Pin_On(Ltr, Idx, High, PullUp)
#define Pin_High(PortDef)                            Set_Pin_High(PortDef)

// Установка вывода порта как выход и установка единичного логического уровня на выводе порта
#define Set_Pin_Out_High(Ltr, Idx, Level, PullUp)    { Set_Pin_Out(Ltr, Idx, Level, PullUp); Set_Pin_High(Ltr, Idx, Level, PullUp); }
#define Pin_Out_High(PortDef)                        Set_Pin_Out_High(PortDef)

// Установка неактивного логического уровня на выводе порта
#define ClrPin(Ltr, Idx)                             Clr_PORT_Bit(Ltr, Idx)
#define ClrPinLow(Ltr, Idx)	                         Set_PORT_Bit(Ltr, Idx)
#define ClrPinHigh(Ltr, Idx)	                       Clr_PORT_Bit(Ltr, Idx)
#define ClrPinOff(Ltr, Idx)	                         Clr_PORT_Bit(Ltr, Idx)
#define ClrPinLowOff(Ltr, Idx)	                     Set_PORT_Bit(Ltr, Idx)
#define ClrPinHighOff(Ltr, Idx)	                     Clr_PORT_Bit(Ltr, Idx)
#define ClrPinOn(Ltr, Idx)	                         Set_DDR_Bit(Ltr, Idx)
#define ClrPinLowOn(Ltr, Idx)	                       Clr_DDR_Bit(Ltr, Idx)
#define ClrPinHighOn(Ltr, Idx)	                     Set_DDR_Bit(Ltr, Idx)
#define Set_Pin_Off(Ltr, Idx, Level, PullUp)	       ClrPin##Level##PullUp(Ltr, Idx)
#define Pin_Off(PortDef)	                           Set_Pin_Off(PortDef)

// Установка неактивного логического уровня на выводе порта
#define Set_Pin_Out_Off(Ltr, Idx, Level, PullUp)     { Set_Pin_Out(Ltr, Idx, Level, PullUp); Set_Pin_Off(Ltr, Idx, Level, PullUp); }
#define Pin_Out_Off(PortDef)                         Set_Pin_Out_Off(PortDef)

// Установка нулевого логического уровня на выводе порта
#define Set_Pin_Low(Ltr, Idx, Level, PullUp)         Set_Pin_Off(Ltr, Idx, High, PullUp)
#define Pin_Low(PortDef)                             Set_Pin_Low(PortDef)

// Установка вывода порта как выход и установка нулевого логического уровня на выводе порта
#define Set_Pin_Out_Low(Ltr, Idx, Level, PullUp)     { Set_Pin_Out(Ltr, Idx, Level, PullUp); Set_Pin_Low(Ltr, Idx, Level, PullUp); }
#define Pin_Out_Low(PortDef)                         Set_Pin_Out_Low(PortDef)

// Проверка логического уровня на выводе порта
#define GetPinSignal(Ltr, Idx)	                     Get_PIN_State(Ltr, Idx)
#define GetPinSignalLow(Ltr, Idx)	                   (!Get_PIN_State(Ltr, Idx))
#define GetPinSignalHigh(Ltr, Idx)	                 Get_PIN_State(Ltr, Idx)
#define Get_Pin_Signal(Ltr, Idx, Level, PullUp)      GetPinSignal##Level(Ltr, Idx)
#define Get_Pin_State(Ltr, Idx, Level, PullUp)       GetPinSignal##Level(Ltr, Idx)
#define Pin_Signal(PortDef)                          Get_Pin_Signal(PortDef)
#define Pin_State(PortDef)                           Get_Pin_Signal(PortDef)
#define Test_Pin(PortDef)                            Get_Pin_Signal(PortDef)

// Изменение логического уровня на выводе порта на противоположное
#define Invert(Ltr, Idx)                             Invert_PORT_Bit(Ltr, Idx)
#define InvertOff(Ltr, Idx)                          Invert_PORT_Bit(Ltr, Idx)
#define InvertOn(Ltr, Idx)                           Invert_DDR_Bit(Ltr, Idx)
#define Change_Pin_Signal(Ltr, Idx, Level, PullUp)	 Invert##PullUp(Ltr, Idx)
#define Invert_Pin_Signal(Ltr, Idx, Level, PullUp)	 Change_Pin_Signal(Ltr, Idx, Level, PullUp)
#define Toggle_Pin_Signal(Ltr, Idx, Level, PullUp)	 Change_Pin_Signal(Ltr, Idx, Level, PullUp)
#define Pin_Change(PortDef)                          Invert_Pin_Signal(PortDef)
#define Pin_Invert(PortDef)                          Invert_Pin_Signal(PortDef)
#define Pin_Toggle(PortDef)                          Invert_Pin_Signal(PortDef)
#define Change_Pin(PortDef)                          Invert_Pin_Signal(PortDef)
#define Invert_Pin(PortDef)                          Invert_Pin_Signal(PortDef)
#define Toggle_Pin(PortDef)                          Invert_Pin_Signal(PortDef)

////////////////////////////////////////////////////////////////////////////////////////////////////

//
#define BYTES(Value)    ((Byte *) & (Value))
#define WORDS(Value)    ((Word *) & (Value))

// Конфигурационные биты и биты блокировки
#define _DataToZByte(Addr, Value)     __AddrToZByteToSPMCR_LPM((void __flash *)(Addr), (Value))
#define _DataToR0Byte(Addr, Value)    __DataToR0ByteToSPMCR_SPM((Addr), (Value))
#define Get_Lock_Bits()               _DataToZByte(0x0001, 0x09)
#define Set_Lock_Bits(Value)          _DataToR0Byte(Value, 0x09)
#define Get_Low_Fuses()               _DataToZByte(0x0000, 0x09)
#define Get_High_Fuses()              _DataToZByte(0x0003, 0x09)
#define Get_Extended_Fuses()          _DataToZByte(0x0002, 0x09)
#define Enable_RWW_Section()          _DataToR0Byte(0x00, 0x11)

//
#define INLINE                              _Pragma("inline=forced")
#define DisableUndefinedBehaviorWarning			_Pragma(diag_suppress=Pa082)
#define EnableUndefinedBehaviorWarning			_Pragma(diag_default=Pa082)

//
#define Array_Length(Value)     (sizeof(Value) / sizeof(Value[0]))

#endif	// __Macros_Included__