//////////////////////////////////////////////////////////////////////////////////////////////////// // Макроопределения. // // (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 #include // Циклы #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 #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 <имя> , , [], [] // // - Буква порта (A, B, C, и т. д.). // - Номер вывода порта (0-7). // - Активный уровень. (High или Low, если не указан, то High); // High - логическая единица; // Low - логический ноль. // - Внешний подтягивающий резистор. (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__