; This file was created with EvAVRbuilder.dll library. 25.11.2018 13:39:07

//-- device --
;***** THIS IS A MACHINE GENERATED FILE - DO NOT EDIT ********************
;***** Created: 2011-08-25 21:00 ******* Source: ATmega8A.xml ************
;*************************************************************************
;* A P P L I C A T I O N   N O T E   F O R   T H E   A V R   F A M I L Y
;* 
;* Number            : AVR000
;* File Name         : "m8Adef.inc"
;* Title             : Register/Bit Definitions for the ATmega8A
;* Date              : 2011-08-25
;* Version           : 2.35
;* Support E-mail    : avr@atmel.com
;* Target MCU        : ATmega8A
;* 
;* DESCRIPTION
;* When including this file in the assembly program file, all I/O register 
;* names and I/O register bit names appearing in the data book can be used.
;* In addition, the six registers forming the three data pointers X, Y and 
;* Z have been assigned names XL - ZH. Highest RAM address for Internal 
;* SRAM is also defined 
;* 
;* The Register names are represented by their hexadecimal address.
;* 
;* The Register Bit names are represented by their bit number (0-7).
;* 
;* Please observe the difference in using the bit names with instructions
;* such as "sbr"/"cbr" (set/clear bit in register) and "sbrs"/"sbrc"
;* (skip if bit in register set/cleared). The following example illustrates
;* this:
;* 
;* in    r16,PORTB             ;read PORTB latch
;* sbr   r16,(1<<PB6)+(1<<PB5) ;set PB6 and PB5 (use masks, not bit#)
;* out   PORTB,r16             ;output to PORTB
;* 
;* in    r16,TIFR              ;read the Timer Interrupt Flag Register
;* sbrc  r16,TOV0              ;test the overflow flag (use bit#)
;* rjmp  TOV0_is_set           ;jump if set
;* ...                         ;otherwise do something else
;*************************************************************************

#ifndef _M8ADEF_INC_
#define _M8ADEF_INC_


#pragma partinc 0

; ***** SPECIFY DEVICE ***************************************************
.device ATmega8A
#pragma AVRPART ADMIN PART_NAME ATmega8A
.equ	SIGNATURE_000	= 0x1e
.equ	SIGNATURE_001	= 0x93
.equ	SIGNATURE_002	= 0x07

#pragma AVRPART CORE CORE_VERSION V2E


; ***** I/O REGISTER DEFINITIONS *****************************************
; NOTE:
; Definitions marked "MEMORY MAPPED"are extended I/O ports
; and cannot be used with IN/OUT instructions
.equ	SREG	= 0x3f
.equ	SPL	= 0x3d
.equ	SPH	= 0x3e
.equ	GICR	= 0x3b
.equ	GIFR	= 0x3a
.equ	TIMSK	= 0x39
.equ	TIFR	= 0x38
.equ	SPMCR	= 0x37
.equ	TWCR	= 0x36
.equ	MCUCR	= 0x35
.equ	MCUCSR	= 0x34
.equ	TCCR0	= 0x33
.equ	TCNT0	= 0x32
.equ	OSCCAL	= 0x31
.equ	SFIOR	= 0x30
.equ	TCCR1A	= 0x2f
.equ	TCCR1B	= 0x2e
.equ	TCNT1L	= 0x2c
.equ	TCNT1H	= 0x2d
.equ	OCR1AL	= 0x2a
.equ	OCR1AH	= 0x2b
.equ	OCR1BL	= 0x28
.equ	OCR1BH	= 0x29
.equ	ICR1L	= 0x26
.equ	ICR1H	= 0x27
.equ	TCCR2	= 0x25
.equ	TCNT2	= 0x24
.equ	OCR2	= 0x23
.equ	ASSR	= 0x22
.equ	WDTCR	= 0x21
.equ	UBRRH	= 0x20
.equ	UCSRC	= 0x20
.equ	EEARL	= 0x1e
.equ	EEARH	= 0x1f
.equ	EEDR	= 0x1d
.equ	EECR	= 0x1c
.equ	PORTB	= 0x18
.equ	DDRB	= 0x17
.equ	PINB	= 0x16
.equ	PORTC	= 0x15
.equ	DDRC	= 0x14
.equ	PINC	= 0x13
.equ	PORTD	= 0x12
.equ	DDRD	= 0x11
.equ	PIND	= 0x10
.equ	SPDR	= 0x0f
.equ	SPSR	= 0x0e
.equ	SPCR	= 0x0d
.equ	UDR	= 0x0c
.equ	UCSRA	= 0x0b
.equ	UCSRB	= 0x0a
.equ	UBRRL	= 0x09
.equ	ACSR	= 0x08
.equ	ADMUX	= 0x07
.equ	ADCSRA	= 0x06
.equ	ADCL	= 0x04
.equ	ADCH	= 0x05
.equ	TWDR	= 0x03
.equ	TWAR	= 0x02
.equ	TWSR	= 0x01
.equ	TWBR	= 0x00


; ***** BIT DEFINITIONS **************************************************

; ***** ANALOG_COMPARATOR ************
; SFIOR - Special Function IO Register
.equ	ACME	= 3	; Analog Comparator Multiplexer Enable

; ACSR - Analog Comparator Control And Status Register
.equ	ACIS0	= 0	; Analog Comparator Interrupt Mode Select bit 0
.equ	ACIS1	= 1	; Analog Comparator Interrupt Mode Select bit 1
.equ	ACIC	= 2	; Analog Comparator Input Capture Enable
.equ	ACIE	= 3	; Analog Comparator Interrupt Enable
.equ	ACI	= 4	; Analog Comparator Interrupt Flag
.equ	ACO	= 5	; Analog Compare Output
.equ	ACBG	= 6	; Analog Comparator Bandgap Select
.equ	ACD	= 7	; Analog Comparator Disable


; ***** SPI **************************
; SPDR - SPI Data Register
.equ	SPDR0	= 0	; SPI Data Register bit 0
.equ	SPDR1	= 1	; SPI Data Register bit 1
.equ	SPDR2	= 2	; SPI Data Register bit 2
.equ	SPDR3	= 3	; SPI Data Register bit 3
.equ	SPDR4	= 4	; SPI Data Register bit 4
.equ	SPDR5	= 5	; SPI Data Register bit 5
.equ	SPDR6	= 6	; SPI Data Register bit 6
.equ	SPDR7	= 7	; SPI Data Register bit 7

; SPSR - SPI Status Register
.equ	SPI2X	= 0	; Double SPI Speed Bit
.equ	WCOL	= 6	; Write Collision Flag
.equ	SPIF	= 7	; SPI Interrupt Flag

; SPCR - SPI Control Register
.equ	SPR0	= 0	; SPI Clock Rate Select 0
.equ	SPR1	= 1	; SPI Clock Rate Select 1
.equ	CPHA	= 2	; Clock Phase
.equ	CPOL	= 3	; Clock polarity
.equ	MSTR	= 4	; Master/Slave Select
.equ	DORD	= 5	; Data Order
.equ	SPE	= 6	; SPI Enable
.equ	SPIE	= 7	; SPI Interrupt Enable


; ***** EXTERNAL_INTERRUPT ***********
; GICR - General Interrupt Control Register
.equ	GIMSK	= GICR	; For compatibility
.equ	IVCE	= 0	; Interrupt Vector Change Enable
.equ	IVSEL	= 1	; Interrupt Vector Select
.equ	INT0	= 6	; External Interrupt Request 0 Enable
.equ	INT1	= 7	; External Interrupt Request 1 Enable

; GIFR - General Interrupt Flag Register
.equ	INTF0	= 6	; External Interrupt Flag 0
.equ	INTF1	= 7	; External Interrupt Flag 1

; MCUCR - MCU Control Register
.equ	ISC00	= 0	; Interrupt Sense Control 0 Bit 0
.equ	ISC01	= 1	; Interrupt Sense Control 0 Bit 1
.equ	ISC10	= 2	; Interrupt Sense Control 1 Bit 0
.equ	ISC11	= 3	; Interrupt Sense Control 1 Bit 1


; ***** TIMER_COUNTER_0 **************
; TIMSK - Timer/Counter Interrupt Mask Register
.equ	TOIE0	= 0	; Timer/Counter0 Overflow Interrupt Enable

; TIFR - Timer/Counter Interrupt Flag register
.equ	TOV0	= 0	; Timer/Counter0 Overflow Flag

; TCCR0 - Timer/Counter0 Control Register
.equ	CS00	= 0	; Clock Select0 bit 0
.equ	CS01	= 1	; Clock Select0 bit 1
.equ	CS02	= 2	; Clock Select0 bit 2

; TCNT0 - Timer Counter 0
.equ	TCNT00	= 0	; Timer Counter 0 bit 0
.equ	TCNT01	= 1	; Timer Counter 0 bit 1
.equ	TCNT02	= 2	; Timer Counter 0 bit 2
.equ	TCNT03	= 3	; Timer Counter 0 bit 3
.equ	TCNT04	= 4	; Timer Counter 0 bit 4
.equ	TCNT05	= 5	; Timer Counter 0 bit 5
.equ	TCNT06	= 6	; Timer Counter 0 bit 6
.equ	TCNT07	= 7	; Timer Counter 0 bit 7


; ***** TIMER_COUNTER_1 **************
; TIMSK - Timer/Counter Interrupt Mask Register
.equ	TOIE1	= 2	; Timer/Counter1 Overflow Interrupt Enable
.equ	OCIE1B	= 3	; Timer/Counter1 Output CompareB Match Interrupt Enable
.equ	OCIE1A	= 4	; Timer/Counter1 Output CompareA Match Interrupt Enable
.equ	TICIE1	= 5	; Timer/Counter1 Input Capture Interrupt Enable

; TIFR - Timer/Counter Interrupt Flag register
.equ	TOV1	= 2	; Timer/Counter1 Overflow Flag
.equ	OCF1B	= 3	; Output Compare Flag 1B
.equ	OCF1A	= 4	; Output Compare Flag 1A
.equ	ICF1	= 5	; Input Capture Flag 1

; TCCR1A - Timer/Counter1 Control Register A
.equ	WGM10	= 0	; Waveform Generation Mode
.equ	PWM10	= WGM10	; For compatibility
.equ	WGM11	= 1	; Waveform Generation Mode
.equ	PWM11	= WGM11	; For compatibility
.equ	FOC1B	= 2	; Force Output Compare 1B
.equ	FOC1A	= 3	; Force Output Compare 1A
.equ	COM1B0	= 4	; Compare Output Mode 1B, bit 0
.equ	COM1B1	= 5	; Compare Output Mode 1B, bit 1
.equ	COM1A0	= 6	; Compare Ouput Mode 1A, bit 0
.equ	COM1A1	= 7	; Compare Output Mode 1A, bit 1

; TCCR1B - Timer/Counter1 Control Register B
.equ	CS10	= 0	; Prescaler source of Timer/Counter 1
.equ	CS11	= 1	; Prescaler source of Timer/Counter 1
.equ	CS12	= 2	; Prescaler source of Timer/Counter 1
.equ	WGM12	= 3	; Waveform Generation Mode
.equ	CTC10	= WGM12	; For compatibility
.equ	CTC1	= WGM12	; For compatibility
.equ	WGM13	= 4	; Waveform Generation Mode
.equ	CTC11	= WGM13	; For compatibility
.equ	ICES1	= 6	; Input Capture 1 Edge Select
.equ	ICNC1	= 7	; Input Capture 1 Noise Canceler


; ***** TIMER_COUNTER_2 **************
; TIMSK - Timer/Counter Interrupt Mask register
.equ	TOIE2	= 6	; Timer/Counter2 Overflow Interrupt Enable
.equ	OCIE2	= 7	; Timer/Counter2 Output Compare Match Interrupt Enable

; TIFR - Timer/Counter Interrupt Flag Register
.equ	TOV2	= 6	; Timer/Counter2 Overflow Flag
.equ	OCF2	= 7	; Output Compare Flag 2

; TCCR2 - Timer/Counter2 Control Register
.equ	CS20	= 0	; Clock Select bit 0
.equ	CS21	= 1	; Clock Select bit 1
.equ	CS22	= 2	; Clock Select bit 2
.equ	WGM21	= 3	; Waveform Generation Mode
.equ	CTC2	= WGM21	; For compatibility
.equ	COM20	= 4	; Compare Output Mode bit 0
.equ	COM21	= 5	; Compare Output Mode bit 1
.equ	WGM20	= 6	; Waveform Genration Mode
.equ	PWM2	= WGM20	; For compatibility
.equ	FOC2	= 7	; Force Output Compare

; TCNT2 - Timer/Counter2
.equ	TCNT2_0	= 0	; Timer/Counter 2 bit 0
.equ	TCNT2_1	= 1	; Timer/Counter 2 bit 1
.equ	TCNT2_2	= 2	; Timer/Counter 2 bit 2
.equ	TCNT2_3	= 3	; Timer/Counter 2 bit 3
.equ	TCNT2_4	= 4	; Timer/Counter 2 bit 4
.equ	TCNT2_5	= 5	; Timer/Counter 2 bit 5
.equ	TCNT2_6	= 6	; Timer/Counter 2 bit 6
.equ	TCNT2_7	= 7	; Timer/Counter 2 bit 7

; OCR2 - Timer/Counter2 Output Compare Register
.equ	OCR2_0	= 0	; Timer/Counter2 Output Compare Register Bit 0
.equ	OCR2_1	= 1	; Timer/Counter2 Output Compare Register Bit 1
.equ	OCR2_2	= 2	; Timer/Counter2 Output Compare Register Bit 2
.equ	OCR2_3	= 3	; Timer/Counter2 Output Compare Register Bit 3
.equ	OCR2_4	= 4	; Timer/Counter2 Output Compare Register Bit 4
.equ	OCR2_5	= 5	; Timer/Counter2 Output Compare Register Bit 5
.equ	OCR2_6	= 6	; Timer/Counter2 Output Compare Register Bit 6
.equ	OCR2_7	= 7	; Timer/Counter2 Output Compare Register Bit 7

; ASSR - Asynchronous Status Register
.equ	TCR2UB	= 0	; Timer/counter Control Register2 Update Busy
.equ	OCR2UB	= 1	; Output Compare Register2 Update Busy
.equ	TCN2UB	= 2	; Timer/Counter2 Update Busy
.equ	AS2	= 3	; Asynchronous Timer/counter2

; SFIOR - Special Function IO Register
.equ	PSR2	= 1	; Prescaler Reset Timer/Counter2


; ***** USART ************************
; UDR - USART I/O Data Register
.equ	UDR0	= 0	; USART I/O Data Register bit 0
.equ	UDR1	= 1	; USART I/O Data Register bit 1
.equ	UDR2	= 2	; USART I/O Data Register bit 2
.equ	UDR3	= 3	; USART I/O Data Register bit 3
.equ	UDR4	= 4	; USART I/O Data Register bit 4
.equ	UDR5	= 5	; USART I/O Data Register bit 5
.equ	UDR6	= 6	; USART I/O Data Register bit 6
.equ	UDR7	= 7	; USART I/O Data Register bit 7

; UCSRA - USART Control and Status Register A
.equ	USR	= UCSRA	; For compatibility
.equ	MPCM	= 0	; Multi-processor Communication Mode
.equ	U2X	= 1	; Double the USART transmission speed
.equ	UPE	= 2	; Parity Error
.equ	PE	= UPE	; For compatibility
.equ	DOR	= 3	; Data overRun
.equ	FE	= 4	; Framing Error
.equ	UDRE	= 5	; USART Data Register Empty
.equ	TXC	= 6	; USART Transmitt Complete
.equ	RXC	= 7	; USART Receive Complete

; UCSRB - USART Control and Status Register B
.equ	UCR	= UCSRB	; For compatibility
.equ	TXB8	= 0	; Transmit Data Bit 8
.equ	RXB8	= 1	; Receive Data Bit 8
.equ	UCSZ2	= 2	; Character Size
.equ	CHR9	= UCSZ2	; For compatibility
.equ	TXEN	= 3	; Transmitter Enable
.equ	RXEN	= 4	; Receiver Enable
.equ	UDRIE	= 5	; USART Data register Empty Interrupt Enable
.equ	TXCIE	= 6	; TX Complete Interrupt Enable
.equ	RXCIE	= 7	; RX Complete Interrupt Enable

; UCSRC - USART Control and Status Register C
.equ	UCPOL	= 0	; Clock Polarity
.equ	UCSZ0	= 1	; Character Size
.equ	UCSZ1	= 2	; Character Size
.equ	USBS	= 3	; Stop Bit Select
.equ	UPM0	= 4	; Parity Mode Bit 0
.equ	UPM1	= 5	; Parity Mode Bit 1
.equ	UMSEL	= 6	; USART Mode Select
.equ	URSEL	= 7	; Register Select

.equ	UBRRHI	= UBRRH	; For compatibility

; ***** TWI **************************
; TWBR - TWI Bit Rate register
.equ	I2BR	= TWBR	; For compatibility
.equ	TWBR0	= 0	; 
.equ	TWBR1	= 1	; 
.equ	TWBR2	= 2	; 
.equ	TWBR3	= 3	; 
.equ	TWBR4	= 4	; 
.equ	TWBR5	= 5	; 
.equ	TWBR6	= 6	; 
.equ	TWBR7	= 7	; 

; TWCR - TWI Control Register
.equ	I2CR	= TWCR	; For compatibility
.equ	TWIE	= 0	; TWI Interrupt Enable
.equ	I2IE	= TWIE	; For compatibility
.equ	TWEN	= 2	; TWI Enable Bit
.equ	I2EN	= TWEN	; For compatibility
.equ	ENI2C	= TWEN	; For compatibility
.equ	TWWC	= 3	; TWI Write Collition Flag
.equ	I2WC	= TWWC	; For compatibility
.equ	TWSTO	= 4	; TWI Stop Condition Bit
.equ	I2STO	= TWSTO	; For compatibility
.equ	TWSTA	= 5	; TWI Start Condition Bit
.equ	I2STA	= TWSTA	; For compatibility
.equ	TWEA	= 6	; TWI Enable Acknowledge Bit
.equ	I2EA	= TWEA	; For compatibility
.equ	TWINT	= 7	; TWI Interrupt Flag
.equ	I2INT	= TWINT	; For compatibility

; TWSR - TWI Status Register
.equ	I2SR	= TWSR	; For compatibility
.equ	TWPS0	= 0	; TWI Prescaler
.equ	TWS0	= TWPS0	; For compatibility
.equ	I2GCE	= TWPS0	; For compatibility
.equ	TWPS1	= 1	; TWI Prescaler
.equ	TWS1	= TWPS1	; For compatibility
.equ	TWS3	= 3	; TWI Status
.equ	I2S3	= TWS3	; For compatibility
.equ	TWS4	= 4	; TWI Status
.equ	I2S4	= TWS4	; For compatibility
.equ	TWS5	= 5	; TWI Status
.equ	I2S5	= TWS5	; For compatibility
.equ	TWS6	= 6	; TWI Status
.equ	I2S6	= TWS6	; For compatibility
.equ	TWS7	= 7	; TWI Status
.equ	I2S7	= TWS7	; For compatibility

; TWDR - TWI Data register
.equ	I2DR	= TWDR	; For compatibility
.equ	TWD0	= 0	; TWI Data Register Bit 0
.equ	TWD1	= 1	; TWI Data Register Bit 1
.equ	TWD2	= 2	; TWI Data Register Bit 2
.equ	TWD3	= 3	; TWI Data Register Bit 3
.equ	TWD4	= 4	; TWI Data Register Bit 4
.equ	TWD5	= 5	; TWI Data Register Bit 5
.equ	TWD6	= 6	; TWI Data Register Bit 6
.equ	TWD7	= 7	; TWI Data Register Bit 7

; TWAR - TWI (Slave) Address register
.equ	I2AR	= TWAR	; For compatibility
.equ	TWGCE	= 0	; TWI General Call Recognition Enable Bit
.equ	TWA0	= 1	; TWI (Slave) Address register Bit 0
.equ	TWA1	= 2	; TWI (Slave) Address register Bit 1
.equ	TWA2	= 3	; TWI (Slave) Address register Bit 2
.equ	TWA3	= 4	; TWI (Slave) Address register Bit 3
.equ	TWA4	= 5	; TWI (Slave) Address register Bit 4
.equ	TWA5	= 6	; TWI (Slave) Address register Bit 5
.equ	TWA6	= 7	; TWI (Slave) Address register Bit 6


; ***** WATCHDOG *********************
; WDTCR - Watchdog Timer Control Register
.equ	WDTCSR	= WDTCR	; For compatibility
.equ	WDP0	= 0	; Watch Dog Timer Prescaler bit 0
.equ	WDP1	= 1	; Watch Dog Timer Prescaler bit 1
.equ	WDP2	= 2	; Watch Dog Timer Prescaler bit 2
.equ	WDE	= 3	; Watch Dog Enable
.equ	WDCE	= 4	; Watchdog Change Enable
.equ	WDTOE	= WDCE	; For compatibility


; ***** PORTB ************************
; PORTB - Port B Data Register
.equ	PORTB0	= 0	; Port B Data Register bit 0
.equ	PB0	= 0	; For compatibility
.equ	PORTB1	= 1	; Port B Data Register bit 1
.equ	PB1	= 1	; For compatibility
.equ	PORTB2	= 2	; Port B Data Register bit 2
.equ	PB2	= 2	; For compatibility
.equ	PORTB3	= 3	; Port B Data Register bit 3
.equ	PB3	= 3	; For compatibility
.equ	PORTB4	= 4	; Port B Data Register bit 4
.equ	PB4	= 4	; For compatibility
.equ	PORTB5	= 5	; Port B Data Register bit 5
.equ	PB5	= 5	; For compatibility
.equ	PORTB6	= 6	; Port B Data Register bit 6
.equ	PB6	= 6	; For compatibility
.equ	PORTB7	= 7	; Port B Data Register bit 7
.equ	PB7	= 7	; For compatibility

; DDRB - Port B Data Direction Register
.equ	DDB0	= 0	; Port B Data Direction Register bit 0
.equ	DDB1	= 1	; Port B Data Direction Register bit 1
.equ	DDB2	= 2	; Port B Data Direction Register bit 2
.equ	DDB3	= 3	; Port B Data Direction Register bit 3
.equ	DDB4	= 4	; Port B Data Direction Register bit 4
.equ	DDB5	= 5	; Port B Data Direction Register bit 5
.equ	DDB6	= 6	; Port B Data Direction Register bit 6
.equ	DDB7	= 7	; Port B Data Direction Register bit 7

; PINB - Port B Input Pins
.equ	PINB0	= 0	; Port B Input Pins bit 0
.equ	PINB1	= 1	; Port B Input Pins bit 1
.equ	PINB2	= 2	; Port B Input Pins bit 2
.equ	PINB3	= 3	; Port B Input Pins bit 3
.equ	PINB4	= 4	; Port B Input Pins bit 4
.equ	PINB5	= 5	; Port B Input Pins bit 5
.equ	PINB6	= 6	; Port B Input Pins bit 6
.equ	PINB7	= 7	; Port B Input Pins bit 7


; ***** PORTC ************************
; PORTC - Port C Data Register
.equ	PORTC0	= 0	; Port C Data Register bit 0
.equ	PC0	= 0	; For compatibility
.equ	PORTC1	= 1	; Port C Data Register bit 1
.equ	PC1	= 1	; For compatibility
.equ	PORTC2	= 2	; Port C Data Register bit 2
.equ	PC2	= 2	; For compatibility
.equ	PORTC3	= 3	; Port C Data Register bit 3
.equ	PC3	= 3	; For compatibility
.equ	PORTC4	= 4	; Port C Data Register bit 4
.equ	PC4	= 4	; For compatibility
.equ	PORTC5	= 5	; Port C Data Register bit 5
.equ	PC5	= 5	; For compatibility
.equ	PORTC6	= 6	; Port C Data Register bit 6
.equ	PC6	= 6	; For compatibility

; DDRC - Port C Data Direction Register
.equ	DDC0	= 0	; Port C Data Direction Register bit 0
.equ	DDC1	= 1	; Port C Data Direction Register bit 1
.equ	DDC2	= 2	; Port C Data Direction Register bit 2
.equ	DDC3	= 3	; Port C Data Direction Register bit 3
.equ	DDC4	= 4	; Port C Data Direction Register bit 4
.equ	DDC5	= 5	; Port C Data Direction Register bit 5
.equ	DDC6	= 6	; Port C Data Direction Register bit 6

; PINC - Port C Input Pins
.equ	PINC0	= 0	; Port C Input Pins bit 0
.equ	PINC1	= 1	; Port C Input Pins bit 1
.equ	PINC2	= 2	; Port C Input Pins bit 2
.equ	PINC3	= 3	; Port C Input Pins bit 3
.equ	PINC4	= 4	; Port C Input Pins bit 4
.equ	PINC5	= 5	; Port C Input Pins bit 5
.equ	PINC6	= 6	; Port C Input Pins bit 6


; ***** PORTD ************************
; PORTD - Port D Data Register
.equ	PORTD0	= 0	; Port D Data Register bit 0
.equ	PD0	= 0	; For compatibility
.equ	PORTD1	= 1	; Port D Data Register bit 1
.equ	PD1	= 1	; For compatibility
.equ	PORTD2	= 2	; Port D Data Register bit 2
.equ	PD2	= 2	; For compatibility
.equ	PORTD3	= 3	; Port D Data Register bit 3
.equ	PD3	= 3	; For compatibility
.equ	PORTD4	= 4	; Port D Data Register bit 4
.equ	PD4	= 4	; For compatibility
.equ	PORTD5	= 5	; Port D Data Register bit 5
.equ	PD5	= 5	; For compatibility
.equ	PORTD6	= 6	; Port D Data Register bit 6
.equ	PD6	= 6	; For compatibility
.equ	PORTD7	= 7	; Port D Data Register bit 7
.equ	PD7	= 7	; For compatibility

; DDRD - Port D Data Direction Register
.equ	DDD0	= 0	; Port D Data Direction Register bit 0
.equ	DDD1	= 1	; Port D Data Direction Register bit 1
.equ	DDD2	= 2	; Port D Data Direction Register bit 2
.equ	DDD3	= 3	; Port D Data Direction Register bit 3
.equ	DDD4	= 4	; Port D Data Direction Register bit 4
.equ	DDD5	= 5	; Port D Data Direction Register bit 5
.equ	DDD6	= 6	; Port D Data Direction Register bit 6
.equ	DDD7	= 7	; Port D Data Direction Register bit 7

; PIND - Port D Input Pins
.equ	PIND0	= 0	; Port D Input Pins bit 0
.equ	PIND1	= 1	; Port D Input Pins bit 1
.equ	PIND2	= 2	; Port D Input Pins bit 2
.equ	PIND3	= 3	; Port D Input Pins bit 3
.equ	PIND4	= 4	; Port D Input Pins bit 4
.equ	PIND5	= 5	; Port D Input Pins bit 5
.equ	PIND6	= 6	; Port D Input Pins bit 6
.equ	PIND7	= 7	; Port D Input Pins bit 7


; ***** EEPROM ***********************
; EEDR - EEPROM Data Register
.equ	EEDR0	= 0	; EEPROM Data Register bit 0
.equ	EEDR1	= 1	; EEPROM Data Register bit 1
.equ	EEDR2	= 2	; EEPROM Data Register bit 2
.equ	EEDR3	= 3	; EEPROM Data Register bit 3
.equ	EEDR4	= 4	; EEPROM Data Register bit 4
.equ	EEDR5	= 5	; EEPROM Data Register bit 5
.equ	EEDR6	= 6	; EEPROM Data Register bit 6
.equ	EEDR7	= 7	; EEPROM Data Register bit 7

; EECR - EEPROM Control Register
.equ	EERE	= 0	; EEPROM Read Enable
.equ	EEWE	= 1	; EEPROM Write Enable
.equ	EEMWE	= 2	; EEPROM Master Write Enable
.equ	EEWEE	= EEMWE	; For compatibility
.equ	EERIE	= 3	; EEPROM Ready Interrupt Enable


; ***** CPU **************************
; SREG - Status Register
.equ	SREG_C	= 0	; Carry Flag
.equ	SREG_Z	= 1	; Zero Flag
.equ	SREG_N	= 2	; Negative Flag
.equ	SREG_V	= 3	; Two's Complement Overflow Flag
.equ	SREG_S	= 4	; Sign Bit
.equ	SREG_H	= 5	; Half Carry Flag
.equ	SREG_T	= 6	; Bit Copy Storage
.equ	SREG_I	= 7	; Global Interrupt Enable

; MCUCR - MCU Control Register
;.equ	ISC00	= 0	; Interrupt Sense Control 0 Bit 0
;.equ	ISC01	= 1	; Interrupt Sense Control 0 Bit 1
;.equ	ISC10	= 2	; Interrupt Sense Control 1 Bit 0
;.equ	ISC11	= 3	; Interrupt Sense Control 1 Bit 1
.equ	SM0	= 4	; Sleep Mode Select
.equ	SM1	= 5	; Sleep Mode Select
.equ	SM2	= 6	; Sleep Mode Select
.equ	SE	= 7	; Sleep Enable

; MCUCSR - MCU Control And Status Register
.equ	MCUSR	= MCUCSR	; For compatibility
.equ	PORF	= 0	; Power-on reset flag
.equ	EXTRF	= 1	; External Reset Flag
.equ	BORF	= 2	; Brown-out Reset Flag
.equ	WDRF	= 3	; Watchdog Reset Flag

; OSCCAL - Oscillator Calibration Value
.equ	CAL0	= 0	; Oscillator Calibration Value Bit0
.equ	CAL1	= 1	; Oscillator Calibration Value Bit1
.equ	CAL2	= 2	; Oscillator Calibration Value Bit2
.equ	CAL3	= 3	; Oscillator Calibration Value Bit3
.equ	CAL4	= 4	; Oscillator Calibration Value Bit4
.equ	CAL5	= 5	; Oscillator Calibration Value Bit5
.equ	CAL6	= 6	; Oscillator Calibration Value Bit6
.equ	CAL7	= 7	; Oscillator Calibration Value Bit7

; SPMCR - Store Program Memory Control Register
.equ	SPMEN	= 0	; Store Program Memory Enable
.equ	PGERS	= 1	; Page Erase
.equ	PGWRT	= 2	; Page Write
.equ	BLBSET	= 3	; Boot Lock Bit Set
.equ	RWWSRE	= 4	; Read-While-Write Section Read Enable
.equ	RWWSB	= 6	; Read-While-Write Section Busy
.equ	SPMIE	= 7	; SPM Interrupt Enable

; SFIOR - Special Function IO Register
.equ	PSR10	= 0	; Prescaler Reset Timer/Counter1 and Timer/Counter0
.equ	PUD	= 2	; Pull-up Disable
.equ	ADHSM	= 4	; ADC High Speed Mode


; ***** AD_CONVERTER *****************
; ADMUX - The ADC multiplexer Selection Register
.equ	MUX0	= 0	; Analog Channel and Gain Selection Bits
.equ	MUX1	= 1	; Analog Channel and Gain Selection Bits
.equ	MUX2	= 2	; Analog Channel and Gain Selection Bits
.equ	MUX3	= 3	; Analog Channel and Gain Selection Bits
.equ	ADLAR	= 5	; Left Adjust Result
.equ	REFS0	= 6	; Reference Selection Bit 0
.equ	REFS1	= 7	; Reference Selection Bit 1

; ADCSRA - The ADC Control and Status register
.equ	ADCSR	= ADCSRA	; For compatibility
.equ	ADPS0	= 0	; ADC  Prescaler Select Bits
.equ	ADPS1	= 1	; ADC  Prescaler Select Bits
.equ	ADPS2	= 2	; ADC  Prescaler Select Bits
.equ	ADIE	= 3	; ADC Interrupt Enable
.equ	ADIF	= 4	; ADC Interrupt Flag
.equ	ADFR	= 5	; ADC  Free Running Select
.equ	ADSC	= 6	; ADC Start Conversion
.equ	ADEN	= 7	; ADC Enable



; ***** LOCKSBITS ********************************************************
.equ	LB1	= 0	; Lock bit
.equ	LB2	= 1	; Lock bit
.equ	BLB01	= 2	; Boot Lock bit
.equ	BLB02	= 3	; Boot Lock bit
.equ	BLB11	= 4	; Boot lock bit
.equ	BLB12	= 5	; Boot lock bit


; ***** FUSES ************************************************************
; LOW fuse bits
.equ	CKSEL0	= 0	; Select Clock Source
.equ	CKSEL1	= 1	; Select Clock Source
.equ	CKSEL2	= 2	; Select Clock Source
.equ	CKSEL3	= 3	; Select Clock Source
.equ	SUT0	= 4	; Select start-up time
.equ	SUT1	= 5	; Select start-up time
.equ	BODEN	= 6	; Brown out detector enable
.equ	BODLEVEL	= 7	; Brown out detector trigger level

; HIGH fuse bits
.equ	BOOTRST	= 0	; Select Reset Vector
.equ	BOOTSZ0	= 1	; Select Boot Size
.equ	BOOTSZ1	= 2	; Select Boot Size
.equ	EESAVE	= 3	; EEPROM memory is preserved through chip erase
.equ	CKOPT	= 4	; Oscillator Options
.equ	SPIEN	= 5	; Enable Serial programming and Data Downloading
.equ	WTDON	= 6	; Enable watchdog
.equ	RSTDISBL	= 7	; Disable reset



; ***** CPU REGISTER DEFINITIONS *****************************************
.def	XH	= r27
.def	XL	= r26
.def	YH	= r29
.def	YL	= r28
.def	ZH	= r31
.def	ZL	= r30



; ***** DATA MEMORY DECLARATIONS *****************************************
.equ	FLASHEND	= 0x0fff	; Note: Word address
.equ	IOEND	= 0x003f
.equ	SRAM_START	= 0x0060
.equ	SRAM_SIZE	= 1024
.equ	RAMEND	= 0x045f
.equ	XRAMEND	= 0x0000
.equ	E2END	= 0x01ff
.equ	EEPROMEND	= 0x01ff
.equ	EEADRBITS	= 9
#pragma AVRPART MEMORY PROG_FLASH 8192
#pragma AVRPART MEMORY EEPROM 512
#pragma AVRPART MEMORY INT_SRAM SIZE 1024
#pragma AVRPART MEMORY INT_SRAM START_ADDR 0x60



; ***** BOOTLOADER DECLARATIONS ******************************************
.equ	NRWW_START_ADDR	= 0xc00
.equ	NRWW_STOP_ADDR	= 0xfff
.equ	RWW_START_ADDR	= 0x0
.equ	RWW_STOP_ADDR	= 0xbff
.equ	PAGESIZE	= 32
.equ	FIRSTBOOTSTART	= 0xf80
.equ	SECONDBOOTSTART	= 0xf00
.equ	THIRDBOOTSTART	= 0xe00
.equ	FOURTHBOOTSTART	= 0xc00
.equ	SMALLBOOTSTART	= FIRSTBOOTSTART
.equ	LARGEBOOTSTART	= FOURTHBOOTSTART



; ***** INTERRUPT VECTORS ************************************************
.equ	INT0addr	= 0x0001	; External Interrupt Request 0
.equ	INT1addr	= 0x0002	; External Interrupt Request 1
.equ	OC2addr	= 0x0003	; Timer/Counter2 Compare Match
.equ	OVF2addr	= 0x0004	; Timer/Counter2 Overflow
.equ	ICP1addr	= 0x0005	; Timer/Counter1 Capture Event
.equ	OC1Aaddr	= 0x0006	; Timer/Counter1 Compare Match A
.equ	OC1Baddr	= 0x0007	; Timer/Counter1 Compare Match B
.equ	OVF1addr	= 0x0008	; Timer/Counter1 Overflow
.equ	OVF0addr	= 0x0009	; Timer/Counter0 Overflow
.equ	SPIaddr	= 0x000a	; Serial Transfer Complete
.equ	URXCaddr	= 0x000b	; USART, Rx Complete
.equ	UDREaddr	= 0x000c	; USART Data Register Empty
.equ	UTXCaddr	= 0x000d	; USART, Tx Complete
.equ	ADCCaddr	= 0x000e	; ADC Conversion Complete
.equ	ERDYaddr	= 0x000f	; EEPROM Ready
.equ	ACIaddr	= 0x0010	; Analog Comparator
.equ	TWIaddr	= 0x0011	; 2-wire Serial Interface
.equ	SPMRaddr	= 0x0012	; Store Program Memory Ready

.equ	INT_VECTORS_SIZE	= 19	; size in words

#pragma AVRPART CORE INSTRUCTIONS_NOT_SUPPORTED break

#endif  /* _M8ADEF_INC_ */

; ***** END OF FILE ******************************************************
/*
 * hr_avr.asm
 *  Created: 30.06.2018 10:12:37
 *   Author: Lihouzov Evgeny
 */
 
//========================= Таблица векторов прерываний ======================================
rjmp   load_cfg;
//-- Interrupt --
; ***** INTERRUPT VECTORS ************************************************
reti                     ;0x0001 External Interrupt Request 0  (iINT0addr)
reti                     ;0x0002 External Interrupt Request 1  (iINT1addr)
reti                     ;0x0003 Timer/Counter2 Compare Match  (iOC2addr)
reti                     ;0x0004 Timer/Counter2 Overflow  (iOVF2addr)
reti                     ;0x0005 Timer/Counter1 Capture Event  (iICP1addr)
reti                     ;0x0006 Timer/Counter1 Compare Match A  (iOC1Aaddr)
reti                     ;0x0007 Timer/Counter1 Compare Match B  (iOC1Baddr)
reti                     ;0x0008 Timer/Counter1 Overflow  (iOVF1addr)
rjmp iOVF0addr           ;0x0009 Timer/Counter0 Overflow
reti                     ;0x000a Serial Transfer Complete  (iSPIaddr)
reti                     ;0x000b USART, Rx Complete  (iURXCaddr)
reti                     ;0x000c USART Data Register Empty  (iUDREaddr)
reti                     ;0x000d USART, Tx Complete  (iUTXCaddr)
reti                     ;0x000e ADC Conversion Complete  (iADCCaddr)
reti                     ;0x000f EEPROM Ready  (iERDYaddr)
reti                     ;0x0010 Analog Comparator  (iACIaddr)
reti                     ;0x0011 2-wire Serial Interface  (iTWIaddr)
reti                     ;0x0012 Store Program Memory Ready  (iSPMRaddr)
;****	INT_VECTORS_SIZE	= 19	; size in word     ****
;****   Vector count = 19 ****
;****   Vector size  = 19 ****
.org INT_VECTORS_SIZE

//Используемые регистры
  .def  Addr_Data       = r0   //адрес дата (используется в функциях ядра)
  .def  Kern_A          = r1   //регистр временного хранения данных используеться ядром
  .def  Zero            = r2   //Регистр с нулевым значением !!!
  .def  One             = r3   //Регистр с еденичным значением !!!
  .def  Uzel_Count      = r4   //количество соеденительных узлов в конфигурации
  .def  FBD_size        = r5   //Размер описания FBD блока
  .def  FBD_mem         = r6   //Размер данных оперативной памяти

  .def  Uz1L            = r7   //Узловая переменная
  .def  Uz1H            = r8   //Узловая переменная
  .def  Uz2L            = r9   //Узловая переменная
  .def  Uz2H            = r10  //Узловая переменная
  .def  Uz3L            = r11  //Узловая переменная
  .def  Uz3H            = r12  //Узловая переменная
  .def  A               = r16  //регистр временного хранения данных
  .def  B               = r17  //регистр временного хранения данных
  .def  C               = r18   //регистр временного хранения данных
  .def  D               = r19  //регистр временного хранения данных
  .def  E               = r20  //регистр временного хранения данных
  .def  F               = r21  //регистр временного хранения данных
  .def  G               = r22  //регистр временного хранения данных
  .def  H               = r23  //регистр временного хранения данных

  .def  iA              = r24  //прерывания регистр временного хранения данных
  .def  iB              = r25  //прерывания регистр временного хранения данных

//  .def	Adr_RAM_H	    = r27  //Указатель на оперативную память     XH
//  .def	Adr_RAM_L	    = r26  //Указатель на оперативную память     XL
//  .def	Adr_EEPROM_H	= r29  //Указатель на энергонезависимую память   YH
//  .def	Adr_EEPROM_L	= r28  //Указатель на энергонезависимую память   YL
//  .def	Adr_flash_H	    = r31                                        ZH
//  .def	Adr_flash_L	    = r30                                        ZL


.MACRO    UOUT               //UOUT обходит "MEMORY MAPPED" использовать вместо out 
.if	@0 < 0x40
      	out	@0,@1         
.else
      	sts	@0,@1
.endif
.ENDMACRO

.MACRO    UIN               //UIN обходит "MEMORY MAPPED" использовать вместо in 
.if	@1 < 0x40
      	in	@0,@1         
.else
      	lds	@0,@1
.endif
.ENDMACRO

.MACRO    USBI               //USBI обходит "MEMORY MAPPED" использовать вместо sbi 
.if	@0 < 0x40
      	sbi	@0,@1         
.else
      	lds	H,@0
        ori     H, 1 << @1
        sts     @0, H 
.endif
.ENDMACRO

.MACRO    UCBI               //UCBI обходит "MEMORY MAPPED" использовать вместо cbi 
.if	@0 < 0x40
      	cbi	@0,@1         
.else
      	lds	H,@0
        cbr     H,@1
        sts     @0, H 
.endif
.ENDMACRO

.MACRO    USBIC               //USBIC обходит "MEMORY MAPPED" использовать вместо sbic 
.if	@0 < 0x40
      	sbic 	@0,@1         
.else
      	lds	H,@0
        sbrc    H,@1
.endif
.ENDMACRO

.SET FBD_DATA_RAM = SRAM_START  //Указатель на данные FBD блоков в оперативной памяти
//-- Include --
//************************************************ FBD ****************************************************
#ifndef _FBD0_
#define _FBD0_ FBD0
#message define FBD0 (ADC_in)__FILE__

//Размер описания FDB блока 2 байта
//1 байт- Привязка к выходу
//1 байт- Конфигурация
FBD0_data:
  .db 0b11111110, 0b11111101, 0b11111011, 0b11110111, 0b11101111, 0b11011111
FBD0_init:
 ADIW  YL, 1                              //пропускаем 1 байт "выход"
 rcall Read_cfg                           //Байт конфигурации
 ldi   A, 0b00000111                      //Маска 
 and   A, Addr_Data                       //Выделяем № пина
 ldi   ZL, Low(FBD0_data*2)              //Указатель на табл
 ldi   ZH, High(FBD0_data*2)             //Указатель на табл
 add   ZL, A                              //Смещаем
 adc   ZH, Zero                           //Смещаем
 lpm                                      //Извлекаем маску для порта
 in    B, DDRC                            //Читаем состояние порта
 and   B, Addr_Data                       //Накладываем маску
 out   DDRC, B                            //Устанавливаем
 ret;



FBD0_run:
 rcall Read_cfg                           //Читаем байт конфигурации
 mov   B, Addr_Data                       //Привязка к выводу FBD блока 
 rcall Read_cfg                           //Читаем байт конфигурации
 mov   C, Addr_Data                       //Байт конфигурации
 ldi   ZL, Low(ADC_DATA_RAM_ADR)          //Указатель на оперативную память ADC_DATA_RAM_ADR
 ldi   ZH, High(ADC_DATA_RAM_ADR)         //Указатель на оперативную память ADC_DATA_RAM_ADR
 ld    A,  Z                              //Глобальные данные для ADC

 mov   D, C                               //Продготовка к сравнению MUX
 eor   D, A                               //Продготовка к сравнению MUX
 andi  D, 0b00000111                      //Продготовка к сравнению MUX
 brne  FBD0_end                          //Адрес MUX не соответствует


 sbrs  A, 7                               //Проверка на занятость ADC
 rjmp  FBD0_start_ADC                    //Запуск нового измерения  
 sbic  ADCSRA, ADSC                       //Проверка завершения текущего измерения
 rjmp  FBD0_end                          //Измерение не завершено
 cbr   A, 0b10000000                      //Сбрасываем флаг (идет измерение)
 st    Z, A                               //Изменяем глобальную переменную
 in    Uz1L, ADCL                         //Читаем результат
 in    Uz1H, ADCH                         //Читаем результат
 mov   Addr_Data, B                       //Сохраняем значение узла по индексу A
 rcall Save_Uz1                           //Сохраняем значение узла по индексу A
 ret

FBD0_start_ADC:
 sbi   ADCSRA, ADSC                       //Запускаем измерение
 sbr   A, 0b10000000                      //Устанавливаем флаг (идет измерение)
 st    Z, A                               //Изменяем глобальную переменную
FBD0_end: 
 ret;



#else 
 #error redeclared FBD0  __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD1_
#define _FBD1_ FBD1
#message define FBD1 (ADC_ATmega8A_config)__FILE__

.SET ADC_DATA_RAM_ADR = FBD_DATA_RAM  //Глобальные данные для ADC
.SET FBD_DATA_RAM = FBD_DATA_RAM + 1  //Выделяем 1 байт для глобальной переменной ADC
// Stat ADC
//  7   ADC_run
//  0-1 MUX
//Размер описания FDB блока 2 байта
//1 байт- ADCSRA
//1 байт- ADMUX
FBD1_init:
rcall Read_cfg                                                                   ;ADCSRA
out ADCSRA, Addr_Data
rcall Read_cfg                                                                   ;ADMUX
out ADMUX,  Addr_Data
ldi   ZL, Low(ADC_DATA_RAM_ADR)           //Указатель на оперативную память ADC_DATA_RAM_ADR
ldi   ZH, High(ADC_DATA_RAM_ADR)          //Указатель на оперативную память ADC_DATA_RAM_ADR
st  Z, Zero                               //Предварительная установка глобальной переменной
ret;

FBD1_run:
ADIW  YL, 2                               //пропускаем 2 байта конфигурации
ldi   ZL, Low(ADC_DATA_RAM_ADR)           //Указатель на оперативную память ADC_DATA_RAM_ADR
ldi   ZH, High(ADC_DATA_RAM_ADR)          //Указатель на оперативную память ADC_DATA_RAM_ADR
ld    A, Z                                //Глобальные данные для ADC
mov   B, A                                //Глобальные данные для ADC
inc   B                                   //MUX на следующий канал
andi  B, 0b00000111                       //Маска MUX 
andi  A, 0b11111000                       //Маска
add   A, B                                //
sbrc  A, 7                                //Проверка на занятость ADC
rjmp  FBD1_end                           //Если производится измерение выходим
in    C, ADMUX                            //Читаем текущее состояние
andi  C, 0b11111000                       //Маска MUX
add   C, B                                //
out   ADMUX, C                            //Устанавливаем новый канал
st    Z, A                                //Изменяем глобальную переменную
FBD1_end:
ret;

#else
#error redeclared FBD1 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD2_
#define _FBD2_ FBD2
#message define FBD2 (Const) __FILE__

//Размер описания FDB блока 5 байта
//2 байта- значение узловой переменной
//1 байт- привязка к узлу

FBD2_run:
//======== Читаем данные блока из файла конфигураций ========= 
// rcall Read_cfg                                   ;Привязку к узлу
// mov   A, Addr_Data                               ;Привязка к узлу
 rcall Read_cfg                                     ;значение узловой переменной
 mov   Uz1L, Addr_Data                            ;значение узловой переменной Lw
 rcall Read_cfg                                     ;значение узловой переменной
 mov   Uz1H, Addr_Data                            ;значение узловой переменной Hg
//================== Логика работы FBD блока ==================
// mov   Addr_Data, A   
 rcall Read_cfg_Save_Uz1                                   ;Сохраняем значение узла по индексу A
 ret                                              ;Окончание исполнения логики блока
#else 
 #error redeclared FBD2 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD3_
#define _FBD3_ FBD3
#message define FBD3 (integer more)__FILE__

//Размер описания FDB блока 3 байта
//1 байт- вход 1
//1 байт- вход 2
//1 байт- выход
//Оперативной памяти не требуется

FBD3_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg_Load_Uz1                                   ;вход 1 
 rcall Read_cfg_Load_Uz2                                   ;вход 2 
//============= Логика работы FBD блока ==================
 clr  Uz3H                            ;Предварительная установка
 clr  Uz3L                            ;Предварительная установка
 cp   Uz2L, Uz1L                      ;Вычитание
 cpc  Uz2H, Uz1H                      ;Вычитание
 brcc FBD3_zero
 inc  Uz3L                            ;Uz1>Uz2
FBD3_zero:
//============= Сохраняем результат  ==================
 rcall Read_cfg_Save_Uz3                                   ;Сохраняем результат
 ret;

#else 
 #error redeclared FBD3 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD4_
#define _FBD4_ FBD4
#message define FBD4 __FILE__

FBD4_init:
 rcall Read_cfg_Set_Bit_Reg_A                     ;Читаем байт и получаем маску

 in    D, DDRD                                    ;Текущее состояние
 or    D, A                                       ;Устанавливаем бит
 sbrs  Addr_Data, 3                               ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   DDRD, D                                    ;Устанавливаем

 in    D, PORTD                                   ;Читаем состояние вывода
 or    D, A                                       ;Устанавливаем бит
 sbrs  Addr_Data, 4                               ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   PORTD, D                                   ;Устанавливаем

 rcall Read_cfg                                   ;Привязку к узлу
 ret;

FBD4_run:
 rcall Read_cfg_Set_Bit_Reg_A                     ;Читаем байт и получаем маску

 sbrc  Addr_Data, 3                               ;Режим работы порта
 rjmp  FBD4_Out_Pin                               ;

 clr   Uz1L;
 clr   Uz1H;
 in    D, PIND                                    ;Читаем состояние вывода
 and   A, D                                       ;Накладываем маску
 cpse  A, Zero
 inc   Uz1L
 rcall Read_cfg_Save_Uz1                          ;Сохраняем
 ret;

FBD4_Out_Pin: 
 rcall Read_cfg_Load_Uz1                          ;Читаем 
 in    D, PORTD                                   ;Читаем состояние вывода
 or    D, A                                       ;Устанавливаем бит
 sbrs  Uz1L, 0                                    ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   PORTD, D                                   ;Устанавливаем
 ret;

#else 
 #error redeclared FBD4 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD5_
#define _FBD5_ FBD5
#message define FBD5 __FILE__

FBD5_init:
 rcall Read_cfg_Set_Bit_Reg_A                     ;Читаем байт и получаем маску

 in    D, DDRC                                    ;Текущее состояние
 or    D, A                                       ;Устанавливаем бит
 sbrs  Addr_Data, 3                               ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   DDRC, D                                    ;Устанавливаем

 in    D, PORTC                                   ;Читаем состояние вывода
 or    D, A                                       ;Устанавливаем бит
 sbrs  Addr_Data, 4                               ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   PORTC, D                                   ;Устанавливаем

 rcall Read_cfg                                   ;Привязку к узлу
 ret;

FBD5_run:
 rcall Read_cfg_Set_Bit_Reg_A                     ;Читаем байт и получаем маску

 sbrc  Addr_Data, 3                               ;Режим работы порта
 rjmp  FBD5_Out_Pin                               ;

 clr   Uz1L;
 clr   Uz1H;
 in    D, PINC                                    ;Читаем состояние вывода
 and   A, D                                       ;Накладываем маску
 cpse  A, Zero
 inc   Uz1L
 rcall Read_cfg_Save_Uz1                          ;Сохраняем
 ret;

FBD5_Out_Pin: 
 rcall Read_cfg_Load_Uz1                          ;Читаем 
 in    D, PORTC                                   ;Читаем состояние вывода
 or    D, A                                       ;Устанавливаем бит
 sbrs  Uz1L, 0                                    ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   PORTC, D                                   ;Устанавливаем
 ret;

#else 
 #error redeclared FBD5 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD6_
#define _FBD6_ FBD6
#message define FBD6 (Filter)__FILE__

//Размер описания FDB блока 3 байта
//1 байт- вход
//1 байт- сила фильтра
//1 байт- выход
//Оперативная память
//1 байт- состояние 0bffff000X f-счетчик фильтра; X-выход фильтра

FBD6_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg_Load_Uz1                  //вход 
 ld    B,  X                              //Cостояние
 rcall Read_cfg                           //Addr_Data- сила фильтра
//============= Логика работы FBD блока ==================
 mov   A, B                               //Маска
 andi  A, 0b00000001                      //Маска
 eor   A, Uz1L                            //Проверка изменения состояния
 breq  FBD6_clear_counter                //Переход если нет изменений
 ldi   C, 0b00010000                      //Приращение фильтра
 add   B, C                               //Увеличиваем счетчик фильтра
 brcc  FBD6_end                          //Если переполнения небыло то завершаем
 eor   B, One                             //Меняем состояние
FBD6_clear_counter:
 andi B, 0b00000001                       //Сбрасываем счетчик фильтра
 or   B, Addr_Data                        //Сбрасываем счетчик фильтра
FBD6_end:
//============= Сохраняем результат  ==================
 st X+, B                                 //Сохраняем результат
 mov Uz1L, One                            //Выделяем состояние
 and Uz1L, B                              //Выделяем состояние
 rcall Read_cfg_Save_Uz1                  //Выводим состояние 
 ret;

#else 
 #error redeclared FBD6 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD7_
#define _FBD7_ FBD7
#message define FBD7 Countert milliseconds (Timer 0)

#ifdef _Timer0_
#error redeclared Timer0 __FILE__
#endif
#define _Timer0_

.SET TimerCounter0_DATA_SIZE = 6
.SET TimerCounter0_DATA_RAM = FBD_DATA_RAM                               //Глобальные данные для TimerCounter0
.SET FBD_DATA_RAM = TimerCounter0_DATA_RAM + TimerCounter0_DATA_SIZE     //Выделяем память для TimerCounter0
// память:
//  1 байта - TCNT0
//  1 байта - TIMSK

iOVF0addr:  ;Прерывание по таймеру
 LDS iB, TimerCounter0_DATA_RAM+5             ;Задаем значение таймера
 out TCNT0, iB                                ;Задаем значение таймера
 in  iB, SREG                                 ;Сохраняем регистр флагов                                   
 LDS iA, TimerCounter0_DATA_RAM               ;мс в текущем цикле
 add iA, One                                  ;мс в текущем цикле
 STS TimerCounter0_DATA_RAM, iA               ;мс в текущем цикле
 out SREG, iB                                 ;Востанавливаем регистр флагов  
 reti

FBD7_init:
 rcall Read_cfg                                ;Период прерывания
 STS   TimerCounter0_DATA_RAM+5, Addr_Data     ;Период прерывания  
 rcall Read_cfg                                ;Делитель  


#if defined( _TN13ADEF_INC_)||defined(_TN13DEF_INC_)||defined(_TN25DEF_INC_)||defined(_TN45DEF_INC_)||defined(_TN85DEF_INC_)||defined(_M328PDEF_INC_)
.equ _TCCR0=TCCR0B
#else
.equ _TCCR0=TCCR0
#endif

#if defined( _TN13ADEF_INC_)||defined(_TN13DEF_INC_)||defined(_M328PDEF_INC_)
.equ _TIMSK=TIMSK0
#else
.equ _TIMSK=TIMSK
#endif
 
 out _TCCR0, Addr_Data                          ;Делитель                                   
 UIN    A,      _TIMSK                         ;Разрешаем прерывание по переполнению   !!!
 ori   A,     1<<TOIE0                         ;Разрешаем прерывание по переполнению
 UOUT   _TIMSK,  A                             ;Разрешаем прерывание по переполнению

 ret;

FBD7_run:
 ADIW  YL, 2                       ;Пропускаем команды инициализации
 cli                               ;Запрещаем прерывания
 LDS A, TimerCounter0_DATA_RAM     ;мс накопленные за цикл
 STS TimerCounter0_DATA_RAM, Zero  ;мс накопленные за цикл, обнуляем
 sei                               ;Разрешаем прерывания
 LDS B, TimerCounter0_DATA_RAM+1   ;Обновляем счетчик милисекунд
 add B, A                          ;Обновляем счетчик милисекунд
 STS TimerCounter0_DATA_RAM+1, B   ;Обновляем счетчик милисекунд
 LDS B, TimerCounter0_DATA_RAM+2   ;Обновляем счетчик милисекунд
 adc B, Zero                       ;Обновляем счетчик милисекунд
 STS TimerCounter0_DATA_RAM+2, B   ;Обновляем счетчик милисекунд
 LDS B, TimerCounter0_DATA_RAM+3   ;Обновляем счетчик милисекунд
 adc B, Zero                       ;Обновляем счетчик милисекунд
 STS TimerCounter0_DATA_RAM+3, B   ;Обновляем счетчик милисекунд
 LDS B, TimerCounter0_DATA_RAM+4   ;Обновляем счетчик милисекунд
 adc B, Zero                       ;Обновляем счетчик милисекунд
 STS TimerCounter0_DATA_RAM+4, B   ;Обновляем счетчик милисекунд
 ret;



Timer_Diff:
  lds  ZL, TimerCounter0_DATA_RAM+1       //Счетчик Lw
  lds  ZH, TimerCounter0_DATA_RAM+2       //Счетчик Hg
  sub  ZL, Uz1L                           //Разница времени
  sbc  ZH, Uz1H                           //Разница времени
//  brcc Timer_Diff_end
//  neg  ZL                                 //Меняем знак
//  com  ZH                                 //Меняем знак
//Timer_Diff_end:   
  ret 

#else 
 #error redeclared FBD7 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD8_
#define _FBD8_ FBD8
#message define FBD8 time off
;Размер FBD блока
;1 байт  -вход
;2 байта -период
;1 байт  -выход
;Оперативная память:
;  1 байт  - состояние
;  2 байта - отсечка времени

FBD8_run:
  ld    A,    X+                                   ;читаем байт состояния
  ld    Uz1L, X+                                   ;отсечка времени Lw
  ld    Uz1H, X+                                   ;отсечка времени Hw
  sbiw  XL,   3                                    ;Возвращаем указатель

  rcall Read_cfg_Load_Uz2                          ;вход
  rcall Read_cfg                                   ;Читаем длительность  Lw
  mov   C, Addr_Data                               ;Читаем длительность  Lw
  rcall Read_cfg                                   ;Читаем длительность  Hg
  mov   D, Addr_Data                               ;Читаем длительность  Hg
  mov Uz3L, Zero                                   ;Предварительная установка "0"
//***************** Отслеживаем сигнал **********************
  sbrc Uz2L, 0
  rjmp FBD8_start
//*********** Проверка сигнала запуска **********************
  tst  A                     //Тест бита (отсчет времени)
  brpl FBD8_end             //Тест бита (отсчет времени) 
//************* Нет сигнала запуска *************************
  rcall Timer_Diff           //Вычисляем разницу времени
  cp   ZL,  C                //Сраниваем
  cpc  ZH,  D                //Сраниваем
  brmi FBD8_one
  andi A, 0b01111111         //(сбрасываем бит отсчет времени)

FBD8_end:
  st   X+,   A               //сохраняем
  st   X+,   Uz1L            //сохраняем
  st   X+,   Uz1H            //сохраняем
  rcall Read_cfg_Save_Uz3    //выводим состояние
  ret

FBD8_start:
  mov  Uz3L, One                            //выводим 1
  ori  A,   0b10000000                      //(устанавливаем бит отсчет времени)
  lds  Uz1L, TimerCounter0_DATA_RAM+1       //Отсечка времени старта
  lds  Uz1H, TimerCounter0_DATA_RAM+2       //Отсечка времени старта
  rjmp FBD8_end                            //

FBD8_one:
  mov  Uz3L, One               //выводим 1
  rjmp FBD8_end



#else 
 #error redeclared FBD8 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD9_
#define _FBD9_ FBD9
#message define FBD9 (DC trigger)__FILE__

//Размер описания FDB блока 4 байта
//1 байт- вход D
//1 байт- вход C
//1 байт- выход
//1 байт- начальное состояние
//Оперативная память 2 байт
//1 байт вход C в пред. цикле
//1 байт состояние триггера

FBD9_init:     
 ADIW  YL, 3                        //пропускаем первые 3 байт конфигурации
 st    X+, One                      //Вход C в пред. цикле
 rcall Read_cfg                     //Читаем начальное состояние
 st    X+, Addr_Data                //Сохраняем начальное состояние 
 ret                                //Окончание инициализации блока

FBD9_run:
//======== Читаем данные блока ========= 
 ld    B,  X+                      //Вход C в пред. цикле
 ld    A,  X+                      //текущее состояние триггера
 //mov  Uz3L, A                      //Копируем текущее состояние
//============= Логика работы FBD блока ================== 
 rcall Read_cfg_Load_Uz1           //вход D
 rcall Read_cfg_Load_Uz2           //вход C
 eor   B, UZ2L                     //Проверка перехода 0-1 на С
 and   B, UZ2L                     //Проверка перехода 0-1 на С
 sbrc  B, 0                        //Проверка перехода 0-1 на С
 mov  A, UZ1L                      //Был переход копируем 
 mov  Uz3L, A                      //Копируем текущее состояние
//============= Сохраняем результат  ==================
 sbiw  XL, 2                       //Сохраняем
 st X+, UZ2L                       //Сохраняем
 st X+, A                          //Сохраняем
 rcall Read_cfg_Save_Uz3           //Сохраняем результат
 ADIW  YL, 1                       //пропускаем байт конфигурации
 ret;

#else 
 #error redeclared FBD9 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD10_
#define _FBD10_ FBD10
#message define FBD10 (NOT)__FILE__

//Размер описания FDB блока 3 байта
//1 байт- вход
//1 байт- выход
//Оперативной памяти не требуется

FBD10_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg_Load_Uz1                                   ;вход 
//============= Логика работы FBD блока ==================
// ldi  A, 0b00000001                               ;Маска
 com  Uz1L                                        ;Инверсия
 and  Uz1L, One                                     ;and
//============= Сохраняем результат  ==================
 clr   Uz1H                                       ;Сохраняем результат
 rcall Read_cfg_Save_Uz1                                   ;Сохраняем результат
 ret;

#else 
 #error redeclared FBD10 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD11_
#define _FBD11_ FBD11
#message define FBD11 (AND)__FILE__

//Размер описания FDB блока 3 байта
//1 байт- вход 1
//1 байт- вход 2
//1 байт- выход
//Оперативной памяти не требуется

FBD11_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg_Load_Uz1                                   ;вход 1 
 rcall Read_cfg_Load_Uz2                                   ;вход 2 
//============= Логика работы FBD блока ==================
 //ldi  A, 0b00000001                               ;Маска
 and  Uz1L, Uz2L                                  ;and
 and  Uz1L, One                                     ;and
//============= Сохраняем результат  ==================
 clr  Uz1H                                        ;Сохраняем результат
 rcall Read_cfg_Save_Uz1                                   ;Сохраняем результат
 ret;

#else 
 #error redeclared FBD11 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD12_
#define _FBD12_ FBD12
#message define FBD12 __FILE__

FBD12_init:
 rcall Read_cfg_Set_Bit_Reg_A                     ;Читаем байт и получаем маску

 in    D, DDRB                                    ;Текущее состояние
 or    D, A                                       ;Устанавливаем бит
 sbrs  Addr_Data, 3                               ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   DDRB, D                                    ;Устанавливаем

 in    D, PORTB                                   ;Читаем состояние вывода
 or    D, A                                       ;Устанавливаем бит
 sbrs  Addr_Data, 4                               ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   PORTB, D                                   ;Устанавливаем

 rcall Read_cfg                                   ;Привязку к узлу
 ret;

FBD12_run:
 rcall Read_cfg_Set_Bit_Reg_A                     ;Читаем байт и получаем маску

 sbrc  Addr_Data, 3                               ;Режим работы порта
 rjmp  FBD12_Out_Pin                               ;

 clr   Uz1L;
 clr   Uz1H;
 in    D, PINB                                    ;Читаем состояние вывода
 and   A, D                                       ;Накладываем маску
 cpse  A, Zero
 inc   Uz1L
 rcall Read_cfg_Save_Uz1                          ;Сохраняем
 ret;

FBD12_Out_Pin: 
 rcall Read_cfg_Load_Uz1                          ;Читаем 
 in    D, PORTB                                   ;Читаем состояние вывода
 or    D, A                                       ;Устанавливаем бит
 sbrs  Uz1L, 0                                    ;Корректируем
 eor   D, A                                       ;Сбрасываем бит
 out   PORTB, D                                   ;Устанавливаем
 ret;

#else 
 #error redeclared FBD12 __FILE__
#endif
//********************************************************************************************************
//=====================================   C:\Horizont\Configurator\Runtime\HR_AVR\library\lib_real.inc   =====================================
/*
 *  library of real numbers version 1.1
 *
 *  Created: 06.01.2014
 *  Author: Lihouzov Evgeny
 */

#ifdef _real_add_sub_fun_
#define _lib_real_
#endif

#ifdef _real_mul_fun_
#define _lib_real_
#endif

#ifdef _real_div_fun_
#define _lib_real_
#endif

#ifdef _real_Int16ToReal_fun_
#define _lib_real_
#endif

#ifdef _lib_real_
#message define Include library for real numbers in __FILE__

//Извлечение указателя 
Read_Cfg_Load_Pointer_Z:
     rcall Read_cfg                  //Читаем адрес узла
     rcall Set_Adres_Uzl             //Установить указатель Z на адрес узла
     ld    Addr_Data,  Z+            //читаем указатель
     ld    ZH, Z                     //читаем указатель
     mov   ZL, Addr_Data             //читаем указатель
     ret

//Извлечение ABCD 
Read_Cfg_Load_ABCD:
 rcall Read_Cfg_Load_Pointer_Z   //Извлечение указателя
     ld  D, Z+                       //Извлекаем данные
     ld  C, Z+                       //Извлекаем данные
     ld  B, Z+                       //Извлекаем данные
     ld  A, Z+                       //Извлекаем данные
     ret

//Извлечение EFGH 
Read_Cfg_Load_EFGH:
 rcall Read_Cfg_Load_Pointer_Z   //Извлечение указателя
     ld  H, Z+                       //Извлекаем данные
     ld  G, Z+                       //Извлекаем данные
     ld  F, Z+                       //Извлекаем данные
     ld  E, Z+                       //Извлекаем данные
     ret

//Восстановление операнда числа ABCD из базового формата 
lib_real_rec: 
     lsl B       //младший разряд порядка в С 
     rol A       //восстановление порядка 
     lsr B       //сдвиг вправо мантиссы 
     ori B, 0x80 //восстановление скрытой 1  
     ret 

//Упаковка в базовый формат флаг T хранит знак
lib_real_pack: 
    lsl  B     //удаляем старший бит мантиссы 
    lsr  A     //формируем порядок числа
    ror  B     //Замещаем старший разряд мантиссы
    bld  A, 7  //Сохраняем знак
    ret 

//Обмен операндов 
lib_real_swap_ABCD_EFGH: 
    eor A, E   //обмен регистров A, E
    eor E, A 
    eor A, E 
    eor B, F   //обмен регистров B, F
    eor F, B 
    eor B, F 
    eor C, G   //обмен регистров C, G
    eor G, C 
    eor C, G 
    eor D, H   //обмен регистров D, H
    eor H, D 
    eor D, H 
    ret
 
//Cравнения АBCD с 0 
lib_real_cp_ABCD_0: 
    mov ZL, A 
    or  ZL, B 
    or  ZL, C 
    or  ZL, D //при АBCD=0 возвращает флаг Z=l 
    ret        

//Cравнения EFGH с 0
lib_real_cp_EFGH_0: 
    mov ZL, E 
    or  ZL, F 
    or  ZL, G 
    or  ZL, H //при АBCD=0 возвращает флаг Z=l 
    ret   

//Сдвиг вправо 24-разрядной мантиссы числа ABCD
lib_real_shift_ABCD: 
    lsr B 
    ror C 
    ror D 
    clc 
    ret 

//Обнулить ABCD (ABCD=0)
lib_real_clear_ABCD: 
    clr A 
    clr B 
    clr C 
    clr D 
    ret 

#endif


#ifdef _real_add_sub_fun_
#message Include AddF function in __FILE__
#message Include SubF function in __FILE__

//***** модуль сложения и вычитания чисел с плавающей точкой *****// 
real_AddF:                        //сложение вещественных чисел
    mov ZL, A                     //сравнение знаков
    eor ZL, E                     //сравнение знаков
    brpl real_AddFl               //продолжение сложения
    subi E, 0x80                  //изменение знака
    rjmp real_SubF                //вычитание вещественных чисел

real_AddFl: 
    rcall lib_real_cp_EFGH_0      //сравнение EFGH с 0 
    breq real_AddF_Quit           //завершение сложения
    rcall lib_real_cp_ABCD_0      //сравнение ABCD с 0 
    brne real_AddF2               //продолжение сложения
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH 
    ret                           //завершение сложения

real_AddF2: 
    bst  A, 7                     //сохранение знака T=A.7 
    rcall lib_real_rec            //распаковка числа ABDC
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH 
    rcall lib_real_rec            //распаковка числа ABDC 
    mov ZL, A                     //вычитание порядков чисел
    sub ZL, E                     //вычитание порядков чисел         
    brpl real_AddF3               //переход, если порядок ABCD>EFGH 
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH 
    mov ZL, A                     //вычитание порядков чисел
    sub ZL, E                     //вычитание порядков чисел  

real_AddF3: 
    breq real_AddF6               //переход, если порядки чисел равны 
    cpi ZL,24                     //сравниваем c размером мантиссы 24 бита
    brmi real_AddF4               //продолжаем значение
    rjmp real_AddF7               //переход при потере значимости 

real_AddF4: 
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH  

real_AddF5: 
    rcall lib_real_shift_ABCD     //сдвиг мантиссы числа ABCD 
    inc A                         //увеличиваем порядок меньшего числа 
    dec ZL                        //уменьшаем разность порядков 
    brne real_AddF5 

real_AddF6: 
    add D, H                      //сложение мантисс 
    adc C, G                      //сложение мантисс
    adc B, F                      //сложение мантисс
    brcc real_AddF7               //проверка нарушения нормализации 
    inc A                         //корректируем порядок 
    breq real_AddF_Quit           //выход с флагом переполнения (бит C)
    rcall lib_real_shift_ABCD     //сдвиг мантиссы числа ABCD 

real_AddF7: 
    rcall lib_real_pack           //упаковка результата
real_AddF_Quit:
    ret                           //окончание сложения

//==============================================================//
real_SubF:                        //вычитание вещественных чисел
    mov ZL, A                     //сравнение знаков
    eor ZL, E                     //сравнение знаков
    brpl real_SubFl               //продолжение вычитания чисел 
    subi E, 0x80                  //изменение знака 2-го числа      
    rjmp real_AddF                //переход на сложение чисел

real_SubFl: 
    rcall lib_real_cp_EFGH_0      //сравнение EFGH с 0 
    breq real_SubF_Quit           //завершение вычитания
    rcall lib_real_cp_ABCD_0      //сравнение ABCD с 0  
    brne real_SubF2               //продолжение вычитания
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH  
    subi A, 0x80                  //изменение знака 1-го числа 
    ret                           //завершение вычитания

real_SubF2: 
    bst  A, 7                     //сохранение знака T=A.7 
    rcall lib_real_rec            //распаковка числа ABDC
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH 
    rcall lib_real_rec            //распаковка числа ABDC 
    mov ZL, E                     //вычитание порядков чисел
    sub ZL, A                     //вычитание порядков чисел         
    brne real_SubF3               //переход, числа не равны
    cp F, B                       //сравниваем мантиссы
    brne real_SubF3               //переход, числа не равны 
    cp G, C                       //сравниваем мантиссы
    brne real_SubF3               //переход, числа не равны
    cp H, D                       //сравниваем мантиссы
    brne real_SubF3               //переход, числа не равны
    rcall lib_real_clear_ABCD     //присваиваем результат ABCD=0
    ret                           //завершение вычитания
 
real_SubF3: 
    brcc real_SubF4               //переход, если 1-е число больше 
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH  
    bld  ZL, 7                    //изменяем знак в Т
    subi ZL, 0x80                 //изменяем знак в Т
    bst  ZL, 7                    //изменяем знак в Т
 
real_SubF4: 
    mov ZL, E                     //снова вычитание порядков 
    sub ZL, A                     //снова вычитание порядков
    breq real_SubF7               //переход при одинаковых порядках 
    cpi ZL, 24                    //сравниваем c размером мантиссы 24 бита
    brmi real_SubF6               //продолжение вычитания 
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH 
    rjmp real_SubF9               //форматированием результата
 
real_SubF6:
    rcall lib_real_shift_ABCD     //сдвиг мантиссы числа ABCD 
    dec ZL                        //уменьшаем разность порядков 
    brne real_SubF6               //разность порядков не равна О  
    
real_SubF7: 
    sub H, D                      //вычитание мантисс
    mov D, H                      //копирование EFGH->ABCD
    sbc G, C                      //вычитание мантисс с заемом 
    mov C, G                      //копирование EFGH->ABCD 
    sbc F, B                      //вычитание мантисс с заемом 
    mov B, F                      //копирование EFGH->ABCD                  
    mov A, E                      //копирование EFGH->ABCD 

real_SubF8: 
    sbrc B, 7                     //проверка нарушения нормализации 
    rjmp real_SubF9               //переход, если нарушения нет, 
    dec A                         //иначе, не сдвигая мантиссу, 
    cpi A, 0xFF                   //проверяем антипереполнение, 
    sec                           //заранее установив флаг в 1, 
    breq real_SubF_Quit           //при антипереполнении выходим с флагом C=1 
    lsl D                         //сдвигаем мантиссу ABCD влево 
    rol C                         //сдвигаем мантиссу ABCD влево
    rol B                         //сдвигаем мантиссу ABCD влево
    clc                           //сбрасываем флаг C=0
    rjmp real_SubF8               //повторяем проверку
 
real_SubF9: 
    rcall lib_real_pack           //упаковка результата
real_SubF_Quit: 
    ret                           //выход из процедуры вычитания 

#endif

#ifdef _real_mul_fun_
#message Include mulF function in __FILE__
real_MulF:
    clr Uz1L                      //очищаем регистры результата 
    clr Uz1H                      //очищаем регистры результата
    clr Uz2L                      //очищаем регистры результата
    clr Uz2H                      //очищаем регистры результата
    rcall lib_real_cp_EFGH_0      //сравнение EFGH с 0 
    breq real_MulF_Quit           //завершение умножения
    rcall lib_real_cp_ABCD_0      //сравнение ABCD с 0  
    breq real_MulF_Quit           //завершение умножения

    mov ZL, A                     //получение знака произведения 
    eor ZL, E                     //получение знака произведения
    bst ZL, 7                     //сохранение знака в Т 

    rcall lib_real_rec            //распаковка числа ABDC
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH 
    rcall lib_real_rec            //распаковка числа ABDC 
 
  //  mov  Uz1L, E                  //сложение смещенных порядков
    add  A, E                     //сложение смещенных порядков
    brcs real_MulFl 
    subi A, 127                   //вычитание лишнего смещения 
    brcc real_MulF2 
    rjmp real_MulF_Quit
 
real_MulFl: 
    ldi ZL, 129                   //если был перенос при сложении 
    add A,  ZL                    // -25б+129=-127 
    brcs real_MulF_Quit           //
  
real_MulF2:                       //умножение мантисс (C=AxB)
    ldi ZL, 24                    //инициализируем счётчик циклов 
real_MulF3:
    ror F                         //сдвиг множителя 
    ror G                         // для анализа младшего бита 
    ror H                         //
    brcc real_MulF4               //если бит множителя равен 1, 
    add Uz2H, D                   // прибавляем множимое(L-байт), 
    adc Uz2L, C                   // затем М-байт 
    adc UZ1H, B                   // и Н-байт 

real_MulF4: 
    dec ZL                        //уменьшаем счетчик циклов 
    brne real_MulF5               //если не конец, повторяем 
    rjmp real_MulF6 

real_MulF5:
    ror Uz1H                      //сдвигаем вправо сумму 
    ror Uz2L                      // частичных 
    ror Uz2H                      // произведений 
    rjmp real_MulF3 
 
real_MulF6:                       //проверка нормализации
    brcc real_MulF7               //результат нормализован 
    ror Uz1H                      //нормализация
    ror Uz2L                      //нормализация
    ror Uz2H                      //нормализация
    inc A                         //увеличиваем порядок 
    sec                           //C=l 
    breq real_MulF_Quit           //выход с флагом переполнения 
real_MulF7:  
    mov D, Uz2H                   //копируем
    mov C, Uz2L                   //копируем
    mov B, Uz1H                   //копируем
//    mov A, Uz1L                   //копируем 
    rcall lib_real_pack           //упаковка результата

real_MulF_Quit: 
    ret                           //операция умножения завершена

#endif

#ifdef _real_div_fun_
#message Include DivF function in __FILE__

real_DivF:
    clr Uz1L                      //очищаем регистры результата 
    clr Uz1H                      //очищаем регистры результата
    clr Uz2L                      //очищаем регистры результата
    clr Uz2H                      //очищаем регистры результата
    rcall lib_real_cp_EFGH_0      //сравнение EFGH с 0 
    sec                           //C=1
    breq real_DivF_Quit           //завершение умножения
    rcall lib_real_cp_ABCD_0      //сравнение ABCD с 0  
    clc                           //C=0
    breq real_DivF_Quit           //завершение умножения

    mov ZL, A                     //получение знака произведения 
    eor ZL, E                     //получение знака произведения
    bst ZL, 7                     //сохранение знака в Т 

    rcall lib_real_rec            //распаковка числа ABDC
    rcall lib_real_swap_ABCD_EFGH //обмен АBCD и EFGH 
    rcall lib_real_rec            //распаковка числа ABDC 
    rcall lib_real_swap_ABCD_EFGH //оставляем их в своих регистрах 
 
    sub A, E                      //Вычитание смещенных порядков
    brcc real_DivFl               //Вычитание смещенных порядков
    ldi ZL, 127                   //при заеме 
    add A, ZL                     //
    brcs real_DivF2               // и отсутствии переноса 
    sec                           //флаг переполнения
    rjmp real_DivF_Quit           //Выходим

real_DivFl: 
    ldi ZL, 127                   //при отсутствии заема 
    add A,  ZL                    //
    brcs real_DivF_Quit           //Выходим при наличии переноса
  
real_DivF2:                       //Деление мантисс (C=A/B)
    clr E                         //Старший байт мантисы делимого
    ldi ZL, 24                    //инициализируем счетчик циклов 
real_DivF3: 
   // push mAL ;сохраняем делимое mA 
   // push mAM ; (остаток) в стеке 
   // push mAH 

    cp  D, H                      //Сравниваем
    cpc C, G                      //Сравниваем
    cpc B, F                      //Сравниваем
    cpc E, Zero

    brcc real_DivF4 
   // pop mAH /возвращаем остаток 
   // pop mAM ;"из стека, т.к. mA<mB 
   // pop mAL                    //C=1
    clc                          //бит частного равен 0 
    rjmp real_DivF5 

real_DivF4:
    sub D, H                     //Вычитаем
    sbc C, G                     //Вычитаем
    sbc B, F                     //Вычитаем
    sbc E, Zero                  //Вычитаем
    sec                          //бит частного равен 1 

real_DivF5: 
    rol Uz2H                      //сдвиг частного влево 
    rol Uz2L                      //сдвиг частного влево
    rol Uz1H                      //сдвиг частного влево
    clc 
    rol D                         //сдвиг делимого влево 
    rol C                         //сдвиг делимого влево
    rol B                         //сдвиг делимого влево
    rol E                         //сдвиг делимого влево
    dec ZL                        //уменьшаем счетчик циклов 
    brne real_DivF3               //повторяем, пока ZL>0 
 
    sbrc Uz1H, 7                  //Проверка нормализации
    rjmp real_DivF6               //результат нормализован 
    rol Uz2H                      //сдвигаем 
    rol Uz2L                      // мантиссу частного 
    rol Uz1H                      // влево 
    dec A                         //уменьшаем порядок частного 
    cpi A,0xFF 
    sec                           //C=1 
    breq real_DivF_Quit           //выход с флагом антипереполнения 
real_DivF6: 
   // mov рА,рС /подготовка результата 
    mov D, Uz2H                  //копируем 
    mov C, Uz2L                  //копируем
    mov B, Uz1H                  //копируем
real_DivF7: 
    rcall lib_real_pack          //упаковка результата 
real_DivF_Quit: 
    ret                          //операция деления завершена 

#endif


#ifdef _real_Int16ToReal_fun_
#message Include Int16ToReal function in __FILE__

real_Int16ToReal:                 //Преобразование Int16(Uz1H,Uz1L) в веществ. (ABCD)
    clr  A                        //Предварительная установка
    mov  B, Uz1H                  //Предварительная установка
    mov  C, Uz1L                  //Предварительная установка
    clr  D                        //Предварительная установка
    rcall lib_real_cp_ABCD_0      //сравнение ABCD с 0  
    breq real_Int16ToReal_Quit_2  //завершение преобразования
	ldi  A, 127+15                //Предварительная установка
    bst  B, 7                     //Сохранение знака в Т
    brtc real_Int16ToReal1        //Положительное число
    com  B                        //Меняем знак
    neg  C                        //Меняем знак
real_Int16ToReal1: 
    sbrc B, 7                     //проверка нарушения нормализации 
    rjmp real_Int16ToReal_Quit    //переход, если нарушения нет, 
    dec A                         //иначе, не сдвигая мантиссу, 
    lsl D                         //сдвигаем мантиссу ABCD влево 
    rol C                         //сдвигаем мантиссу ABCD влево
    rol B                         //сдвигаем мантиссу ABCD влево
    clc                           //сбрасываем флаг C=0
    rjmp real_Int16ToReal1        //повторяем проверку
real_Int16ToReal_Quit: 
    rcall lib_real_pack           //упаковка результата
real_Int16ToReal_Quit_2: 
    ret                           //выход из процедуры вычитания
#endif

//=====================================   C:\Horizont\Configurator\Runtime\HR_AVR\library\lib_one_wire.inc   =====================================
/*
 *  library of one_wire version 1.1
 *
 *  Created: 28.04.2016
 *  Author: Lihouzov Evgeny
 */

#ifdef _lib_one_wire_
#message define Include library for one_wire in __FILE__
//========== Входные параметры
//  C  - Статус команды
//  D  - Счетчик команды
//  E  - Передаваемый бит
//  F  - Передаваемый байт
//  G  - Cчетчик байт передачи / дополнительная пауза
//  H  - Количество байт для передачи 
//  B  - CRC8 принятой посылки                                                
 rcall Read_cfg_Load_Uz1         //Читаем указатель
 mov ZL, Uz1L
 mov ZH, Uz1H
//  Uz1L - Код FBD блока
//  Uz1H - Код FBD блока
//  G    - Дополнительная пауза
//  Uz2H - Пин (0000X000)
//  Z    - Указатель на порт (PINC)

One_wire_begin:   //======= Основная функция обмена данных =========
  BST One, 0                     //Идет обмен данных
//============================= Ожидание ===========================  
  andi D, 0b11111111             //Маска счетчика
  breq One_wire_send_reset
  dec  D                         //Уменьшаем счетчик
  brne One_wire_pause_end
  tst  G
  breq One_wire_pause_end
  ldi  D, 255
  dec  G
One_wire_pause_end:
  ret
//================ проверка занятости порта ========================

//==================== Команда ресет ======================
One_wire_send_reset:
  cpi  C, 0x80
  brmi One_wire_send_byte
  ldi  A, 0b01000000
  and  A, C
  breq One_wire_reset_0
  rcall One_wire_cfg_in           //Переводим порт на ввод данных
  rcall One_wire_set1             //Выводим 1
  ldi   d, 245                    //Ожидаем
  rcall One_wire_wait             //Ожидаем    90*10^-6 сек 
  ld   A, Z                       //Читаем состояние порта
  and  A, Uz2H                    //Маска вывода 
  brne One_wire_error             //Проверка готовности 
  andi C, 0b00111111              //Ресет выполнен
  ldi   D, 2                      //Устанавливаем паузу
  ret
One_wire_reset_0:
  rcall One_wire_cfg_out          //Переводим потр на вывод данных
  rcall One_wire_set0             //Выводим 0
  ori   C, 0b01000000             //Переход на следующий этап ресета   
  ldi   D, 2                      //Устанавливаем паузу  
  ret 
//===================  Передача/прием байта =====================
One_wire_send_byte:
  cpi  E, 0
  breq One_wire_send_paket
  rcall One_wire_cfg_out
  rcall One_wire_set0
  mov A, F
  and A, E
  ldi D, 13                     //10*10^-6 сек
  brne One_wire_send_bit_next
  ldi D, 200                    //90*10^-6 сек
One_wire_send_bit_next:
  or  F, E                        //Сбрасываем бит
  eor F, E                        //Сбрасываем бит  
  rcall One_wire_wait
  rcall One_wire_cfg_in
  rcall One_wire_set1
  ldi D, 1                        //Ожидаем востановления линии
  rcall One_wire_wait             //Ожидаем востановления линии
  or   F, E                       //Устанавливаем в 1
  mov  Addr_Data, One             //Принято 1
  ld   A, Z                       //Читаем состояние порта
  and  A, Uz2H                    //Маска вывода 
  brne One_wire_send_bit_next2
  eor   F, E                      //Сбрасываем  
  clr   Addr_Data                 //Принято 0
One_wire_send_bit_next2: 
  rcall One_wire_CRC_8_calc_bit   //B-CRC8, Addr_Data (0b0000000X)- входной бит, A- временный регистр   
  lsl  E                          //Перевод маски на следующий бит
  breq One_wire_save_recive_byte
  ret
One_wire_save_recive_byte:
  mov  A, ZL
  ldi  ZL, Low(DS18B20_DATA_RAM)  //адрес буфера данных
  ldi  ZH, High(DS18B20_DATA_RAM) //адрес буфера данных
  add  ZL, G
  adc  ZH, Zero
  st   -Z, F                      //Сохраняем принятый байт
  mov  ZL, A 
  clr  ZH
  ret
//================== передача пакета ==================
One_wire_send_paket:
  cpi  H, 0
  breq One_wire_end
  dec  H
  mov  A, ZL
  ldi  ZL, Low(DS18B20_DATA_RAM)  //адрес буфера данных
  ldi  ZH, High(DS18B20_DATA_RAM) //адрес буфера данных
  add  ZL, G
  adc  ZH, Zero
  ld   F, Z                       //Инициализируем передачу байта
  ldi  E, 0x01                    //Инициализируем передачу байта
  mov  ZL, A 
  clr  ZH
  inc  G
  ret
//================== Ошибка =============================== 
One_wire_error:
  ori D, 0x80      
One_wire_end:
  BST Zero, 0                    //Завершение обмена данных
  ret

//*************** Вспомогательные функции *****************
One_wire_cfg_out:
 ldd  A, Z+1
 or   A, Uz2H
 std  Z+1, A
 ret  
One_wire_cfg_in:
 ldd  A, Z+1
 or   A, Uz2H
 eor  A, Uz2H
 std  Z+1, A
 ret 
                                        
One_wire_set1:
 ldd  A, Z+2
 or   A, Uz2H
 std  Z+2, A
 ret  

One_wire_set0:
 ldd  A, Z+2
 or   A, Uz2H
 eor  A, Uz2H
 std  Z+2, A
 ret 

One_wire_wait:
 dec  D
 brne One_wire_wait
 ret

;***************************************************************
;Подпрограмма вычисления контрольной суммы (CRC-8) побитно на лету
; вход - Addr_Data 0b0000000X
; выход - B - контрольная сумма CRC-8
; Ресурсы - A, B 
;***************************************************************
One_wire_CRC_8_calc_bit:     //B-CRC8, Addr_Data (0b0000000X)- входной бит, A- временный регистр
	//	clr		w1CRCtmp	   //Очищаем переменную для вычисления CRC
	//	bld		w1CRCtmp,0	   //Восстанавливаем принятый бит
		eor		Addr_Data, B	   //Исключающее или с принятым битом
		ror		Addr_Data	   //Смотрим - "0" или "1"
		mov		Addr_Data, B       //Перезагружаем контрольную сумму
		brcc	One_wire_CRC_8_next        //Если приняли "0" - переход
		ldi		A, $18  	   //Если приняли "1" - загружаем константу
		eor		Addr_Data, A       //Исключающее или с константой
One_wire_CRC_8_next:
		ror		Addr_Data	   //Сдвигаем контрольную сумму на бит вправо
		mov		B, Addr_Data	   //Сохраняем текущую контрольную сумму
		ret

#endif
//=====================================   C:\Horizont\Configurator\Runtime\HR_AVR\library\lib_modbus.inc   =====================================
/*
 *  library of modbus version 1.1
 *
 *  Created: 28.04.2015
 *  Author: Lihouzov Evgeny
 */

#ifdef _lib_modbus_
#message define Include library for modbus protocol in __FILE__

 //=== FIFO буфер, Входные параметры ===
 //==  Z -указатель на буффер ввода-вывода
 //==  G -размер буффер ввода-вывода
 //==  H -байт для чтения/записи в буффер ввода-вывода 

//*********************************************************************
modbus_FIFO_write_buf:    //Z-указатель G-размер H данные (исп E,F регистры)
  ld   E, Z+            ;указатель чтения
  ld   F, Z             ;указатель записи

  inc  F
  cp   F, G
  brne modbus_FIFO_write_buf_1
  clr  F
modbus_FIFO_write_buf_1:
  
  cp E, F                  ;проверяем
  brne modbus_FIFO_write_buf_2  ;
  set                      ;ошибка
  ret                      ;выходим
modbus_FIFO_write_buf_2:

  mov E,   F
  ld  F,   Z
  st  Z+,  E

  add ZL, F
  adc ZH, Zero
  st  Z,  H           ;записываем
  clt                 ;успешно
  ret                 ;выходим
//*********************************************************************
modbus_FIFO_read_buf:   //Z-указатель G-размер H данные (исп E,F регистры)
  ld   E, Z+            ;указатель чтения
  ld   F, Z             ;указатель записи

  cp E, F                 ;проверяем
  brne modbus_FIFO_read_buf_1  ;
  set                     ;ошибка
  ret                     ;выходим
modbus_FIFO_read_buf_1:

  mov  F, E
  inc  E
  cp   E, G
  brne modbus_FIFO_read_buf_2
  clr  E
modbus_FIFO_read_buf_2:
  
  st  -Z,  E
  adiw Z,  2

  add ZL, F
  adc ZH, Zero
  ld  H,  Z           ;читаем
  clt                 ;успешно
  ret                 ;выходим
//*********************************************************************
modbus_line_write_buf:    //Z-указатель G-размер H данные (исп F регистры)
  ld   F, Z                ;указатель записи
  set                      ;ошибка
  cp   F, G
  breq modbus_line_write_buf_end
  mov  E, F                ;Смещаем указатель
  inc  E                   ;Смещаем указатель
  st   Z+, E               ;Сохраняем указатель
  add  ZL, F
  adc  ZH, Zero
  st   Z,  H               ;записываем
  clt                      ;успешно
modbus_line_write_buf_end:
  ret                 ;выходим

//*********************************************************************
 //=== Вычисление CRC 16 Входные параметры ===
 //==  Z -указатель на оперативную памать
 //==  E -число байт для подсчета CRC_16

modbus_CRC_16_calc:    //Z-указатель E-размер (исп A,B,D,E,F регистры) BA=скс_16
 ldi   A,  0b11111111             //Предварительный результат CRC_16
 ldi   B,  0b11111111             //Предварительный результат CRC_16
 ldi   D,  0b10100000             //Маска полинома 
modbus_CRC_16_Read_Byte:
 ld    F,  Z+                     //Загружаем байт 
 eor   A,  F                      //Суммирование по XOR
 LDI   F,  8                      //Загрузить счетчик бит
modbus_CRC_16_Loop_Bit:
 lsr B                            //Сдвиг регистра результата CRC вправо
 ror A                            //Сдвиг регистра результата CRC вправо
 brcc modbus_CRC_16_Next_Loop_Bit
 eor  B, D                        //Сложить CRC с полиномом
 eor  A, One                      //Сложить CRC с полиномом
modbus_CRC_16_Next_Loop_Bit:
 dec  F                           //Цикл обработки байта
 brne modbus_CRC_16_Loop_Bit      //Цикл обработки байта
 dec  E                           //Цикл перебора байтов
 brne modbus_CRC_16_Read_Byte     //Цикл перебора байтов
 ret    //=== Результат регистры BA=скс_16  ===

//*********************************************************************
 //=== Выполнение команды Входные параметры ===
 //==  Z -указатель на оперативную памать
 //==  A-адрес устройства

modbus_run_comand:    //Z-указатель A-адрес устройства (исп A,B,C,D,E,F регистры) BA=скс_16
  ld   E,  Z                 ;Размер буфера
  st   Z+,  Zero             ;Очищаем буфер приема 
  cpi  E,  4                 ;Проверка формата
  brcs modbus_run_comand_end ;Проверка формата
  ld   F,  Z+                ;Проверка адреса
  cp   F,  A                 ;Проверка адреса
  brne modbus_run_comand_end ;Проверка адреса
  
  ld   C, Z+                 ;Код команды  
  mov  G, ZL                 ;Указатель на данные команды
  mov  H, ZH                 ;Указатель на данные команды
  sbiw ZL, 2                 ;Указатель на начало команды

  rjmp modbus_CRC_16_calc    ;Вычисляем CRC

  ld   F, Z+                 ;Проверка CRC
  cp   B, F                  ;Проверка CRC
  brne modbus_run_comand_end ;Проверка CRC

  ld   F, Z+                 ;Проверка CRC
  cp   A, F                  ;Проверка CRC
  brne modbus_run_comand_end ;Проверка CRC

  ldi  ZL, Low (modbus_function)
  ldi  ZL, Low (modbus_function)
  ijmp                       ;Выполнение команды

modbus_run_comand_end:
 ret  

//Код обработчика команд
modbus_function:
 rjmp modbus_illegal_function      //1-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //2-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //3-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //4-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //5-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //6-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //7-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //8-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //9-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //10-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //11-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //12-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //13-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //14-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //15-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //16-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //17-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //18-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 
 rjmp modbus_illegal_function      //19-READ COIL STATUS	   Получение текущего состояния (ON/OFF) группы логических ячеек. 

#endif
//=====================================   C:\Horizont\Configurator\Runtime\HR_AVR\library\lib_EEPROM.inc   =====================================
/*
 *  library of EEPROM version 1.2
 *
 *  Created: 10.02.2017
 *  Author: Lihouzov Evgeny
 */

#ifdef _lib_EEPROM_rd_wr_byte_
#message define Include library for EEPROM in __FILE__

//*********************************************************************
EEPROM_read_byte:            //F,E-указатель A данные
#if defined(_M328DEF_INC_)||defined(_M328PDEF_INC_) 
   sbic EECR, EEPE           //Wait for completion of previous write
#else
   sbic EECR, EEWE
#endif
   rjmp EEPROM_read_byte     //Wait for completion of previous write

.if EEPROMEND>=256
   out  EEARL, E             //Set address in address register
   out  EEARH, F             //Set address in address register
.else
   out  EEARL, E             //Set address in address register
.endif   
   sbi  EECR,  EERE          //Start eeprom read by writing EERE
   in   A,     EEDR          //Read data from data register
  ret                        //выходим
//*********************************************************************
EEPROM_write_byte:           //F,E-указатель A данные
#if defined(_M328DEF_INC_)||defined(_M328PDEF_INC_) 
   sbic EECR, EEPE           //Wait for completion of previous write
#else
   sbic EECR, EEWE
#endif
   rjmp EEPROM_write_byte    //Wait for completion of previous write
.if EEPROMEND>=256
   out  EEARH, F             //Set address in address register
   out  EEARL, E             //Set address in address register
.else
   out  EEAR,  E             //Set address in address register
.endif 
   out EEDR,   A             //Write data (r16) to data register
#if defined(_M328DEF_INC_)||defined(_M328PDEF_INC_)
   sbi EECR,EEMPE            //Write logical one to EEMPE
   sbi EECR,EEPE             //Start eeprom write by setting EEPE
#else
   sbi EECR,   EEMWE         //Write logical one to EEMPE
   sbi EECR,   EEWE          //Start eeprom write by setting EEPE
#endif
   
  ret                        //выходим
//*********************************************************************
#endif
FBD0:  .DB  0x00, 0x00                                    //f:2 m:0  ADC_ATmega8a_v1_pin.inc
FBD1:  .DB  0x80, 0x40                                    //f:2 m:0  ADC_ATmega8a_v1_conf.inc
FBD2:  .DB  0x04, 0x01, 0x09, 0x00                        //f:3 m:0  const.inc
FBD3:  .DB  0xE6, 0x00, 0x0A, 0x00                        //f:3 m:0  const.inc
FBD4:  .DB  0xB4, 0x00, 0x0B, 0x00                        //f:3 m:0  const.inc
FBD5:  .DB  0xAA, 0x00, 0x0C, 0x00                        //f:3 m:0  const.inc
FBD6:  .DB  0x82, 0x00, 0x0D, 0x00                        //f:3 m:0  const.inc
FBD7:  .DB  0x50, 0x00, 0x0E, 0x00                        //f:3 m:0  const.inc
FBD8:  .DB  0x28, 0x00, 0x0F, 0x00                        //f:3 m:0  const.inc
FBD9:  .DB  0x00, 0x0E, 0x10, 0x00                        //f:3 m:0  integer_more.inc
FBD10: .DB  0x08, 0x10                                    //f:2 m:0  port_D.inc
FBD11: .DB  0x00, 0x0F, 0x11, 0x00                        //f:3 m:0  integer_more.inc
FBD12: .DB  0x40, 0x01, 0x12, 0x00                        //f:3 m:0  const.inc
FBD13: .DB  0x5E, 0x01, 0x13, 0x00                        //f:3 m:0  const.inc
FBD14: .DB  0x01, 0x14                                    //f:2 m:0  port_C.inc
FBD15: .DB  0x12, 0x15                                    //f:2 m:0  port_C.inc
FBD16: .DB  0x91, 0x00, 0x16, 0x00                        //f:3 m:0  const.inc
FBD17: .DB  0x14, 0xC0, 0x19, 0x00                        //f:3 m:1  logic_filter.inc
FBD18: .DB  0x15, 0xC0, 0x1A, 0x00                        //f:3 m:1  logic_filter.inc
FBD19: .DB  0x1B, 0x04                                    //f:2 m:0  ADC_ATmega8a_v1_pin.inc
FBD20: .DB  0x1B, 0x09, 0x1C, 0x00                        //f:3 m:0  integer_more.inc
FBD21: .DB  0xC2, 0x03                                    //f:2 m:0  time_counter_milliseconds.inc
FBD22: .DB  0x1C, 0x2C, 0x01, 0x1D                        //f:4 m:3  time_TOFF.inc
FBD23: .DB  0x00, 0x13, 0x01, 0x00                        //f:3 m:0  integer_more.inc
FBD24: .DB  0x00, 0x12, 0x02, 0x00                        //f:3 m:0  integer_more.inc
FBD25: .DB  0x00, 0x09, 0x03, 0x00                        //f:3 m:0  integer_more.inc
FBD26: .DB  0x00, 0x0A, 0x04, 0x00                        //f:3 m:0  integer_more.inc
FBD27: .DB  0x00, 0x0B, 0x05, 0x00                        //f:3 m:0  integer_more.inc
FBD28: .DB  0x00, 0x0C, 0x06, 0x00                        //f:3 m:0  integer_more.inc
FBD29: .DB  0x00, 0x16, 0x07, 0x00                        //f:3 m:0  integer_more.inc
FBD30: .DB  0x00, 0x0D, 0x08, 0x00                        //f:3 m:0  integer_more.inc
FBD31: .DB  0x09, 0x11                                    //f:2 m:0  port_D.inc
FBD32: .DB  0x19, 0x1A, 0x17, 0x00                        //f:4 m:2  logic_DC_trigger.inc
FBD33: .DB  0x17, 0x18                                    //f:2 m:0  logic_not.inc
FBD34: .DB  0x0D, 0x1D                                    //f:2 m:0  port_C.inc
FBD35: .DB  0x1D, 0x05, 0x1E, 0x00                        //f:3 m:0  logic_and.inc
FBD36: .DB  0x08, 0x01                                    //f:2 m:0  port_B.inc
FBD37: .DB  0x09, 0x02                                    //f:2 m:0  port_B.inc
FBD38: .DB  0x0A, 0x03                                    //f:2 m:0  port_B.inc
FBD39: .DB  0x0B, 0x04                                    //f:2 m:0  port_B.inc
FBD40: .DB  0x0C, 0x05                                    //f:2 m:0  port_B.inc
FBD41: .DB  0x0D, 0x06                                    //f:2 m:0  port_B.inc
FBD42: .DB  0x0E, 0x07                                    //f:2 m:0  port_B.inc
FBD43: .DB  0x0F, 0x08                                    //f:2 m:0  port_B.inc
FBD44: .DB  0x0A, 0x17                                    //f:2 m:0  port_D.inc
FBD45: .DB  0x0B, 0x18                                    //f:2 m:0  port_D.inc
FBD46: .DB  0x0B, 0x1E                                    //f:2 m:0  port_C.inc
//=====================================   kernel.inc   =====================================


.MACRO Clear_All_Memory
//************ Очищаем оперативную память *******************
   ldi   XL, Low(SRAM_START)                  ; Указатель на оперативную память
   ldi   XH, High(SRAM_START)                 ; Указатель на оперативную память

.if SRAM_SIZE>255
   ldi   YL, Low(SRAM_SIZE)                   ; Обьем оперативной памяти
   ldi   YH, High(SRAM_SIZE)                  ; Обьем оперативной памяти
Initial_Memory:
   ST    X+, Zero                             ; установка
   sbiw  Y,  1                                ; уменьшить
   brne  Initial_Memory                       ; Цикл очистки
.else 
   ldi   YL, SRAM_SIZE                        ; Обьем оперативной памяти
Initial_Memory:
   ST    X+, Zero                             ; установка
   dec   YL                                   ; уменьшить
   brne  Initial_Memory                       ; Цикл очистки
.endif
.ENDMACRO

Read_cfg:	
        mov ZL, YL
        mov ZH, YH
        lpm 
	ADIW  YL, 1           ; перевод указателя
	RET

//========================= Работа с файлом конфигурации ======================
  .MACRO Get_Flash_Pointer                           ; Извлеч указатель
     lpm                                             ; Извлекаем указатель
	 ADIW  ZL, 1                                     ; Извлекаем указатель
	 mov   Kern_A, Addr_Data 
     lpm                                             ; Извлекаем указатель
	 mov   ZH, Addr_Data                    ; Извлекаем указатель
	 mov   ZL, Kern_A                       ; Извлекаем указатель          
  .ENDMACRO 

  .MACRO Get_Flash_Byte                              ; Извлеч байт
     lpm                                             ; читаем flash
	 ADIW  ZL, 1                                     ; сдвиг указателя
	 mov   @0, Addr_Data                             ; читаем flash          
  .ENDMACRO 



//============================ Вспомогательные функции =========================
Read_cfg_Set_Bit_Reg_A:
 rcall Read_cfg                       ;Читаем адрес узла
Set_Bit_Reg_A:
 ldi   A, 0b000000001
 sbrc  Addr_Data, 0
 lsl   A
 sbrc  Addr_Data, 1
 lsl   A
 sbrc  Addr_Data, 1
 lsl   A
 sbrc  Addr_Data, 2
 swap  A
ret


.MACRO Set_Adr_Uzl                     ; Установить указатель на адрес узла
  ldi   ZL, Low(FBD_DATA_RAM)   ; адрес узловых переменных 
  ldi   ZH, High(FBD_DATA_RAM)  ; адрес узловых переменных
  add   ZL, @0                ; корректируем указатель
  adc   ZH, Zero              ; корректируем указатель
  add   ZL, @0                ; корректируем указатель
  adc   ZH, Zero              ; корректируем указатель          
.ENDMACRO   

Set_Adres_Uzl:
  ldi   ZL, Low(FBD_DATA_RAM)   ; адрес узловых переменных 
  ldi   ZH, High(FBD_DATA_RAM)  ; адрес узловых переменных
  add   ZL, Addr_Data         ; корректируем указатель
  adc   ZH, Zero              ; корректируем указатель
  add   ZL, Addr_Data         ; корректируем указатель
  adc   ZH, Zero              ; корректируем указатель           
ret;

Read_Cfg_Load_Uz1:
 rcall Read_cfg                       ;Читаем адрес узла
Load_Uz1:
 rcall Set_Adres_Uzl;  //Set_Adr_Uzl Addr_Data                ; Установить указатель на адрес узла
 ld    Uz1L, Z+                       ; читаем данные
 ld    Uz1H, Z+                       ; читаем данные
ret

Read_Cfg_Load_Uz2:
 rcall Read_cfg                       ;Читаем адрес узла
Load_Uz2:
 rcall Set_Adres_Uzl;  //Set_Adr_Uzl Addr_Data                ; Установить указатель на адрес узла
 ld    Uz2L, Z+                       ; читаем данные
 ld    Uz2H, Z+                       ; читаем данные
ret

Read_Cfg_Load_Uz3:
 rcall Read_cfg                       ;Читаем адрес узла
Load_Uz3:
 rcall Set_Adres_Uzl;  // Set_Adr_Uzl Addr_Data                ; Установить указатель на адрес узла
 ld    Uz3L, Z+                       ; читаем данные
 ld    Uz3H, Z+                       ; читаем данные
ret

Read_Cfg_Save_Uz1:
 rcall Read_cfg                       ;Читаем адрес узла
Save_Uz1:
 rcall Set_Adres_Uzl;  // Set_Adr_Uzl Addr_Data                ; Установить указатель на адрес узла
 st    Z+, Uz1L                       ; сохраняем данные
 st    Z+, Uz1H                       ; сохраняем данные
ret

Read_Cfg_Save_Uz2:
 rcall Read_cfg                       ;Читаем адрес узла
Save_Uz2:
 rcall Set_Adres_Uzl;  // Set_Adr_Uzl Addr_Data                ; Установить указатель на адрес узла
 st    Z+, Uz2L                       ; сохраняем данные
 st    Z+, Uz2H                       ; сохраняем данные
ret

Read_Cfg_Save_Uz3:
 rcall Read_cfg                       ;Читаем адрес узла
Save_Uz3:
 rcall Set_Adres_Uzl;  // Set_Adr_Uzl Addr_Data                ; Установить указатель на адрес узла
 st    Z+, Uz3L                       ; сохраняем данные
 st    Z+, Uz3H                       ; сохраняем данные
ret

//==============================  End kernel function ==============================================


 load_cfg:
.if RAMEND>=256
   ldi   A,  Low(RAMEND)      //Указатель на конец памяти
   out   SPL, A              
   ldi   A, High(RAMEND)      //Указатель на конец памяти
   out   SPH, A              
.else
   ldi   A, RAMEND            //Указатель на конец памяти
   out   SPL, A              
.endif   

   clr   Zero                  //Обнуляем
   mov   One, Zero             //Устанавливаем 1
   inc   One                   //Устанавливаем 1
   Clear_All_Memory            //Очищаем оперативную память
   sei 
//========= init cycle ==========
ldi   YL, Low(FBD0*2)                    // Указатель на flash память
ldi   YH, High(FBD0*2)                   // Указатель на flash память
rcall FBD0_init                     //ADC_ATmega8a_v1_pin.inc (0,0,0)
ldi   YL, Low(FBD1*2)                    // Указатель на flash память
ldi   YH, High(FBD1*2)                   // Указатель на flash память
rcall FBD1_init                     //ADC_ATmega8a_v1_conf.inc (1,10000000,01000000)
ldi   YL, Low(FBD10*2)                   // Указатель на flash память
ldi   YH, High(FBD10*2)                  // Указатель на flash память
rcall FBD4_init                     //port_D.inc (4,8,16)
ldi   YL, Low(FBD14*2)                   // Указатель на flash память
ldi   YH, High(FBD14*2)                  // Указатель на flash память
rcall FBD5_init                     //port_C.inc (5,1,20)
ldi   YL, Low(FBD15*2)                   // Указатель на flash память
ldi   YH, High(FBD15*2)                  // Указатель на flash память
rcall FBD5_init                     //port_C.inc (5,18,21)
ldi   YL, Low(FBD19*2)                   // Указатель на flash память
ldi   YH, High(FBD19*2)                  // Указатель на flash память
rcall FBD0_init                     //ADC_ATmega8a_v1_pin.inc (0,27,4)
ldi   YL, Low(FBD21*2)                   // Указатель на flash память
ldi   YH, High(FBD21*2)                  // Указатель на flash память
rcall FBD7_init                     //time_counter_milliseconds.inc (7,962)
ldi   YL, Low(FBD31*2)                   // Указатель на flash память
ldi   YH, High(FBD31*2)                  // Указатель на flash память
rcall FBD4_init                     //port_D.inc (4,9,17)
ldi   XL, Low(FBD_DATA_RAM+67)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+67)          // Указатель на оперативную память
ldi   YL, Low(FBD32*2)                   // Указатель на flash память
ldi   YH, High(FBD32*2)                  // Указатель на flash память
rcall FBD9_init                     //logic_DC_trigger.inc (9,25,26,23,0)
ldi   YL, Low(FBD34*2)                   // Указатель на flash память
ldi   YH, High(FBD34*2)                  // Указатель на flash память
rcall FBD5_init                     //port_C.inc (5,13,29)
ldi   YL, Low(FBD36*2)                   // Указатель на flash память
ldi   YH, High(FBD36*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,8,1)
ldi   YL, Low(FBD37*2)                   // Указатель на flash память
ldi   YH, High(FBD37*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,9,2)
ldi   YL, Low(FBD38*2)                   // Указатель на flash память
ldi   YH, High(FBD38*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,10,3)
ldi   YL, Low(FBD39*2)                   // Указатель на flash память
ldi   YH, High(FBD39*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,11,4)
ldi   YL, Low(FBD40*2)                   // Указатель на flash память
ldi   YH, High(FBD40*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,12,5)
ldi   YL, Low(FBD41*2)                   // Указатель на flash память
ldi   YH, High(FBD41*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,13,6)
ldi   YL, Low(FBD42*2)                   // Указатель на flash память
ldi   YH, High(FBD42*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,14,7)
ldi   YL, Low(FBD43*2)                   // Указатель на flash память
ldi   YH, High(FBD43*2)                  // Указатель на flash память
rcall FBD12_init                    //port_B.inc (12,15,8)
ldi   YL, Low(FBD44*2)                   // Указатель на flash память
ldi   YH, High(FBD44*2)                  // Указатель на flash память
rcall FBD4_init                     //port_D.inc (4,10,23)
ldi   YL, Low(FBD45*2)                   // Указатель на flash память
ldi   YH, High(FBD45*2)                  // Указатель на flash память
rcall FBD4_init                     //port_D.inc (4,11,24)
ldi   YL, Low(FBD46*2)                   // Указатель на flash память
ldi   YH, High(FBD46*2)                  // Указатель на flash память
rcall FBD5_init                     //port_C.inc (5,11,30)
//========= run cycle ==========
Run_FBD:       //main cycle
ldi   YL, Low(FBD0*2)                    // Указатель на flash память
ldi   YH, High(FBD0*2)                   // Указатель на flash память
rcall FBD0_run                      //ADC_ATmega8a_v1_pin.inc (0,0,0)
ldi   YL, Low(FBD1*2)                    // Указатель на flash память
ldi   YH, High(FBD1*2)                   // Указатель на flash память
rcall FBD1_run                      //ADC_ATmega8a_v1_conf.inc (1,10000000,01000000)
ldi   YL, Low(FBD2*2)                    // Указатель на flash память
ldi   YH, High(FBD2*2)                   // Указатель на flash память
rcall FBD2_run                      //const.inc (2,260,9)
ldi   YL, Low(FBD3*2)                    // Указатель на flash память
ldi   YH, High(FBD3*2)                   // Указатель на flash память
rcall FBD2_run                      //const.inc (2,230,10)
ldi   YL, Low(FBD4*2)                    // Указатель на flash память
ldi   YH, High(FBD4*2)                   // Указатель на flash память
rcall FBD2_run                      //const.inc (2,180,11)
ldi   YL, Low(FBD5*2)                    // Указатель на flash память
ldi   YH, High(FBD5*2)                   // Указатель на flash память
rcall FBD2_run                      //const.inc (2,170,12)
ldi   YL, Low(FBD6*2)                    // Указатель на flash память
ldi   YH, High(FBD6*2)                   // Указатель на flash память
rcall FBD2_run                      //const.inc (2,130,13)
ldi   YL, Low(FBD7*2)                    // Указатель на flash память
ldi   YH, High(FBD7*2)                   // Указатель на flash память
rcall FBD2_run                      //const.inc (2,80,14)
ldi   YL, Low(FBD8*2)                    // Указатель на flash память
ldi   YH, High(FBD8*2)                   // Указатель на flash память
rcall FBD2_run                      //const.inc (2,40,15)
ldi   YL, Low(FBD9*2)                    // Указатель на flash память
ldi   YH, High(FBD9*2)                   // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,14,16)
ldi   YL, Low(FBD10*2)                   // Указатель на flash память
ldi   YH, High(FBD10*2)                  // Указатель на flash память
rcall FBD4_run                      //port_D.inc (4,8,16)
ldi   YL, Low(FBD11*2)                   // Указатель на flash память
ldi   YH, High(FBD11*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,15,17)
ldi   YL, Low(FBD12*2)                   // Указатель на flash память
ldi   YH, High(FBD12*2)                  // Указатель на flash память
rcall FBD2_run                      //const.inc (2,320,18)
ldi   YL, Low(FBD13*2)                   // Указатель на flash память
ldi   YH, High(FBD13*2)                  // Указатель на flash память
rcall FBD2_run                      //const.inc (2,350,19)
ldi   YL, Low(FBD14*2)                   // Указатель на flash память
ldi   YH, High(FBD14*2)                  // Указатель на flash память
rcall FBD5_run                      //port_C.inc (5,1,20)
ldi   YL, Low(FBD15*2)                   // Указатель на flash память
ldi   YH, High(FBD15*2)                  // Указатель на flash память
rcall FBD5_run                      //port_C.inc (5,18,21)
ldi   YL, Low(FBD16*2)                   // Указатель на flash память
ldi   YH, High(FBD16*2)                  // Указатель на flash память
rcall FBD2_run                      //const.inc (2,145,22)
ldi   XL, Low(FBD_DATA_RAM+62)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+62)          // Указатель на оперативную память
ldi   YL, Low(FBD17*2)                   // Указатель на flash память
ldi   YH, High(FBD17*2)                  // Указатель на flash память
rcall FBD6_run                      //logic_filter.inc (6,20,11000000,25)
ldi   XL, Low(FBD_DATA_RAM+63)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+63)          // Указатель на оперативную память
ldi   YL, Low(FBD18*2)                   // Указатель на flash память
ldi   YH, High(FBD18*2)                  // Указатель на flash память
rcall FBD6_run                      //logic_filter.inc (6,21,11000000,26)
ldi   YL, Low(FBD19*2)                   // Указатель на flash память
ldi   YH, High(FBD19*2)                  // Указатель на flash память
rcall FBD0_run                      //ADC_ATmega8a_v1_pin.inc (0,27,4)
ldi   YL, Low(FBD20*2)                   // Указатель на flash память
ldi   YH, High(FBD20*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,27,9,28)
ldi   YL, Low(FBD21*2)                   // Указатель на flash память
ldi   YH, High(FBD21*2)                  // Указатель на flash память
rcall FBD7_run                      //time_counter_milliseconds.inc (7,962)
ldi   XL, Low(FBD_DATA_RAM+64)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+64)          // Указатель на оперативную память
ldi   YL, Low(FBD22*2)                   // Указатель на flash память
ldi   YH, High(FBD22*2)                  // Указатель на flash память
rcall FBD8_run                      //time_TOFF.inc (8,28,300,29)
ldi   YL, Low(FBD23*2)                   // Указатель на flash память
ldi   YH, High(FBD23*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,19,1)
ldi   YL, Low(FBD24*2)                   // Указатель на flash память
ldi   YH, High(FBD24*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,18,2)
ldi   YL, Low(FBD25*2)                   // Указатель на flash память
ldi   YH, High(FBD25*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,9,3)
ldi   YL, Low(FBD26*2)                   // Указатель на flash память
ldi   YH, High(FBD26*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,10,4)
ldi   YL, Low(FBD27*2)                   // Указатель на flash память
ldi   YH, High(FBD27*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,11,5)
ldi   YL, Low(FBD28*2)                   // Указатель на flash память
ldi   YH, High(FBD28*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,12,6)
ldi   YL, Low(FBD29*2)                   // Указатель на flash память
ldi   YH, High(FBD29*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,22,7)
ldi   YL, Low(FBD30*2)                   // Указатель на flash память
ldi   YH, High(FBD30*2)                  // Указатель на flash память
rcall FBD3_run                      //integer_more.inc (3,0,13,8)
ldi   YL, Low(FBD31*2)                   // Указатель на flash память
ldi   YH, High(FBD31*2)                  // Указатель на flash память
rcall FBD4_run                      //port_D.inc (4,9,17)
ldi   XL, Low(FBD_DATA_RAM+67)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+67)          // Указатель на оперативную память
ldi   YL, Low(FBD32*2)                   // Указатель на flash память
ldi   YH, High(FBD32*2)                  // Указатель на flash память
rcall FBD9_run                      //logic_DC_trigger.inc (9,25,26,23,0)
ldi   YL, Low(FBD33*2)                   // Указатель на flash память
ldi   YH, High(FBD33*2)                  // Указатель на flash память
rcall FBD10_run                     //logic_not.inc (10,23,24)
ldi   YL, Low(FBD34*2)                   // Указатель на flash память
ldi   YH, High(FBD34*2)                  // Указатель на flash память
rcall FBD5_run                      //port_C.inc (5,13,29)
ldi   YL, Low(FBD35*2)                   // Указатель на flash память
ldi   YH, High(FBD35*2)                  // Указатель на flash память
rcall FBD11_run                     //logic_and.inc (11,29,5,30)
ldi   YL, Low(FBD36*2)                   // Указатель на flash память
ldi   YH, High(FBD36*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,8,1)
ldi   YL, Low(FBD37*2)                   // Указатель на flash память
ldi   YH, High(FBD37*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,9,2)
ldi   YL, Low(FBD38*2)                   // Указатель на flash память
ldi   YH, High(FBD38*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,10,3)
ldi   YL, Low(FBD39*2)                   // Указатель на flash память
ldi   YH, High(FBD39*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,11,4)
ldi   YL, Low(FBD40*2)                   // Указатель на flash память
ldi   YH, High(FBD40*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,12,5)
ldi   YL, Low(FBD41*2)                   // Указатель на flash память
ldi   YH, High(FBD41*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,13,6)
ldi   YL, Low(FBD42*2)                   // Указатель на flash память
ldi   YH, High(FBD42*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,14,7)
ldi   YL, Low(FBD43*2)                   // Указатель на flash память
ldi   YH, High(FBD43*2)                  // Указатель на flash память
rcall FBD12_run                     //port_B.inc (12,15,8)
ldi   YL, Low(FBD44*2)                   // Указатель на flash память
ldi   YH, High(FBD44*2)                  // Указатель на flash память
rcall FBD4_run                      //port_D.inc (4,10,23)
ldi   YL, Low(FBD45*2)                   // Указатель на flash память
ldi   YH, High(FBD45*2)                  // Указатель на flash память
rcall FBD4_run                      //port_D.inc (4,11,24)
ldi   YL, Low(FBD46*2)                   // Указатель на flash память
ldi   YH, High(FBD46*2)                  // Указатель на flash память
rcall FBD5_run                      //port_C.inc (5,11,30)
rjmp  Run_FBD
.DSEG
RAM_global: .BYTE FBD_DATA_RAM-SRAM_START
RAM_uzel:   .BYTE 62
RAM_FBD:    .BYTE 7
RAM_stack:  .BYTE 8
