; This file was created with EvAVRbuilder.dll library. 04.05.2021 14:49:05

//-- 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_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
FBD0_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;

FBD0_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  FBD0_end                           //Если производится измерение выходим
in    C, ADMUX                            //Читаем текущее состояние
andi  C, 0b11111000                       //Маска MUX
add   C, B                                //
out   ADMUX, C                            //Устанавливаем новый канал
st    Z, A                                //Изменяем глобальную переменную
FBD0_end:
ret;

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

//Размер описания FDB блока 5 байта
//1 байт- привязка к узлу
//2 байт- время высокого состояния
//2 байт- время низкого состояния
//1 байт- начальное состояние (высокое или низкое)
//2 байт- начальное время данного состояния
//Необходимый размер оперативной памяти
//1 байт- текущее состояние (высокое или низкое)
//2 байт- текущее время данного состояния
FBD1_init:     
 ADIW  YL, 5                                      ;пропускаем первые пять байт конфигурации
 rcall Read_cfg                                   ;Читаем начальное состояние
 st    X+, Addr_Data                              ;Сохраняем начальное состояние
 rcall Read_cfg                                   ;Читаем начальное начальное время
 st    X+, Addr_Data                              ;Сохраняем начальное начальное время  Lw
 rcall Read_cfg                                   ;Читаем начальное начальное время     Lw
 st    X+, Addr_Data                              ;Сохраняем начальное начальное время Hg
 ret                                              ;Окончание инициализации блока       Hg

FBD1_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg                                     ;Привязку к узлу
 mov   B, Addr_Data                               ;Привязка к узлу
 rcall Read_cfg                                     ;время высокого состояния
 mov   C, Addr_Data                               ;время высокого состояния Lw
 rcall Read_cfg                                     ;время высокого состояния
 mov   D, Addr_Data                               ;время высокого состояния Hg

 rcall Read_cfg                                     ;время низкого состояния
 mov   E, Addr_Data                               ;время низкого состояния  Lw
 rcall Read_cfg                                     ;время низкого состояния
 mov   F, Addr_Data                               ;время низкого состояния  Hg
 ADIW  YL, 3                                      ;пропускаем два байта конфигурации
//========= Читаем данные блока из оперативной памяти =========
 ld    G,  X+                                     ;текущее состояние
 ld    ZL, X+                                     ;текущее время данного состояния Lw
 ld    ZH, X+                                     ;текущее время данного состояния Hw
//============= Логика работы FBD блока ==================
 adiw  ZL, 1                                      ;Увеличиваем время данного состояния
 breq  FBD1_change_sost                           ;Сменить состояние
 cp   ZL, C                                       ;Сравнить с временем высокого состояния
 cpc  ZH, D                                       ;Сравнить с временем высокого состояния
 sbrs G, 0                                        ;Текущее состояние
 cp   ZL, E                                       ;Сравнить с временем низкого состояния
 sbrs G, 0                                        ;Текущее состояние
 cpc  ZH, F                                       ;Сравнить с временем низкого состояния
 brsh  FBD1_change_sost                           ;Сменить состояние
 SBIW  XL, 2                                      ;Смещаем указатель на состояние
 st   X+, ZL                                      ;Сохраняем текущее время
 st   X+, ZH                                      ;Сохраняем текущее время
 rjmp  FBD1_run_end;                              ;Переход
FBD1_change_sost:
 inc   G                                          ;Меняем состояние
 andi  G,  0b00000001                             ;Меняем состояние
 clr   ZL                                         ;Установить время на ноль
 clr   ZH                                         ;Установить время на ноль
 SBIW  XL, 3                                      ;Смещаем указатель на состояние
 st   X+, G                                       ;Сохраняем текущее состояние
 st   X+, ZL                                      ;Сохраняем текущее время
 st   X+, ZH                                      ;Сохраняем текущее время
FBD1_run_end:
 clr   Uz1H                                       ;Устанавливаем значение узловой переменной
 mov   Uz1L, G                                    ;Устанавливаем значение узловой переменной
 mov   Addr_Data, B   
 rcall Save_Uz1                                   ;Сохраняем значение узла по индексу B
 ret                                              ;Окончание исполнения логики блока
#else 
 #error redeclared FBD1 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD2_
#define _FBD2_ FBD2
#message define FBD2 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

FBD2_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;

FBD2_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 FBD2 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD3_
#define _FBD3_ FBD3
#message define FBD3 __FILE__

FBD3_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;

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

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

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

FBD3_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 FBD3 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD4_
#define _FBD4_ FBD4
#message define FBD4 (LCD_HD44780_2x16)__FILE__
.SET LCD_HD44780_STR_LENGTH= 16
.SET LCD_HD44780_STR_COUNT = 2
.SET LCD_HD44780_DATA_SIZE = LCD_HD44780_STR_LENGTH*LCD_HD44780_STR_COUNT
.SET LCD_HD44780_DATA_RAM = FBD_DATA_RAM                          //Глобальные данные для LCD
.SET FBD_DATA_RAM = LCD_HD44780_DATA_RAM + LCD_HD44780_DATA_SIZE  //Выделяем память для LCD
//16 байт - текст
//16 байт - текст

//Размер описания FDB блока 6+32+6=44 байта
//6  байта-команды инициализации
//16 байт- текст инициализации
//16 байт- текст инициализации
//1  байт- выход DB4
//1  байт- выход DB5
//1  байт- выход DB6
//1  байт- выход DB7
//1  байт- выход RS
//1  байт- выход E
// Оперативная память 
//     1 байт статус
//     1 байт счетчик адреса

FBD4_init:
 ADIW  YL, 6         //Пропускаем команды инициализации 
 ldi   A,  LCD_HD44780_DATA_SIZE     
 ldi   B,  0
Loop_LCD_Copy:                
 sub A, One                       
 brcs End_LCD_copy                 
 rcall Read_cfg                        
 mov   ZL, B
 rcall LCD_out_char     
 inc   B
 rjmp  Loop_LCD_copy                 
End_LCD_copy:

 ADIW  YL, 6    
 ldi A, 4             
 st  X+, A    //статус
 st  X+, Zero //счетчик адреса          
ret;



FBD4_run:
 ld G, X+                 //Статус
 ld H, X+                 //счетчик адреса

FBD4_next_run:
 mov A, G
 //inc A
 
 mov  C, A                //Смена адреса
 inc  C
 eor  C, G                //Смена адреса
 swap C                   //Смена адреса
 andi C,0b00000001        //Смена адреса
   

 sbrc G, 7                //Проверка инициализации
 rjmp FBD4_next          //Проверка инициализации

 lsl   A                  //Счетчик команд инициализации
 swap  A                  //Счетчик команд инициализации
 andi  A, 0b00001111      //Счетчик команд инициализации
 cpi   A, 6               //Проверка окончания инициализации
 brcc  FBD4_end_init     //Проверка окончания инициализации
 
 mov  ZH, YH              //Извлеч следующий байт инициализации
 mov  ZL, YL              //Извлеч следующий байт инициализации
 add  ZL, A               //Извлеч следующий байт инициализации
 adc  ZH, Zero            //Извлеч следующий байт инициализации
 
 lpm  B, Z                //Извлеч следующую команду инициализации
 rjmp FBD4_set_pin

FBD4_end_init:
 clr  H                   //Окончание инициализации
 ldi  G, 0b10000000       //Окончание инициализации
 rjmp FBD4_next_run      //Окончание инициализации

FBD4_next:               //Рабочий цикл
 sbrs G, 3                //Проверка адрес/данные
 rjmp FBD4_out_addres    //Проверка адрес/данные

 ldi   ZL, Low(LCD_HD44780_DATA_RAM)   
 ldi   ZH, High(LCD_HD44780_DATA_RAM)      
 add  ZL, H               //Извлеч данные для LCD
 adc  ZH, Zero            //Извлеч данные для LCD
 ld   B,  Z               //Извлеч данные для LCD
 rjmp FBD4_set_pin

FBD4_out_addres:
 mov  B, H
 ori  B, 0b10000000       //Команда адреса
 cpi  H, LCD_HD44780_STR_LENGTH
 brcs FBD4_set_pin
 
// ldi   ZL, Low(LCD_HD44780_DATA_RAM)   
// ldi   ZH, High(LCD_HD44780_DATA_RAM)      
// ld    F,  Z
 ldi  F, 48
 add  B, F

FBD4_set_pin:
 ADIW  YL, 6+LCD_HD44780_DATA_SIZE //пропускаем байты конфигурации

//============= Установка состояния выводов =========
 sbrc G, 2                //Выбор передаваемой тетрады
 swap B                   //Выбор передаваемой тетрады

 clr  Uz1H                //Выводим тетраду
 mov  Uz1L, One           //Выводим тетраду  4 бит
 sbrs B, 4                //Выводим тетраду  4 бит
 clr  Uz1L                //Выводим тетраду  4 бит
 rcall Read_cfg_Save_Uz1  //Сохраняем результат
 mov  Uz1L, One           //Выводим тетраду  5 бит
 sbrs B, 5                //Выводим тетраду  5 бит
 clr  Uz1L                //Выводим тетраду  5 бит
 rcall Read_cfg_Save_Uz1  //Сохраняем результат
 mov  Uz1L, One           //Выводим тетраду  6 бит
 sbrs B, 6                //Выводим тетраду  6 бит
 clr  Uz1L                //Выводим тетраду  6 бит
 rcall Read_cfg_Save_Uz1  //Сохраняем результат
 mov  Uz1L, One           //Выводим тетраду  7 бит
 sbrs B, 7                //Выводим тетраду  7 бит
 clr  Uz1L                //Выводим тетраду  7 бит
 rcall Read_cfg_Save_Uz1  //Сохраняем результат

 mov  Uz1L, One           //Сигнал RS (0-команда  1-данные)
 sbrs G, 7                //Проверка инициализации
 clr  Uz1L                //Проверка инициализации
 sbrs G, 3                //Проверка адрес/данные
 clr  Uz1L                //Проверка адрес/данные
 rcall Read_cfg_Save_Uz1  //Сохраняем результат RS

 inc  G                   //изменение статуса
 andi G, 0b10111111       //изменение статуса

 mov  Uz1L, One           //Сигнал E (1-0 запись данных)
 sbrs G, 0                //Сигнал E формирование
 clr  Uz1L                //Сигнал E формирование
 sbrs G, 1                //Сигнал E формирование
 clr  Uz1L                //Сигнал E формирование
 rcall Read_cfg_Save_Uz1  //Сохраняем результат E
//================ Смена адреса ===========
  add H, C                     //Смена адреса
  cpi H, LCD_HD44780_DATA_SIZE //Смена адреса
  brcs FBD4_save              //Смена адреса
  clr H                        //Перебор с начала
  ldi G, 0b10000000  

// ldi   ZL, Low(LCD_HD44780_DATA_RAM)   
// ldi   ZH, High(LCD_HD44780_DATA_RAM)      
// ld    F,  Z
// inc   F
// andi  F, 0b00111111
// st    Z, F  

FBD4_save:
//============= Сохранение данных =========
  sbiw  XL, 2
  st X+, G
  st X+, H
ret;



LCD_out_char:       //ZL-позиция вывода  Addr_Data-код выводимого символа
  cpi   ZL,  LCD_HD44780_DATA_SIZE
  brcc  LCD_out_char_end
  ldi   ZH, Low(LCD_HD44780_DATA_RAM)
  add   ZL, ZH
  ldi   ZH, High(LCD_HD44780_DATA_RAM)
  adc   ZH, Zero
  st    Z,  Addr_Data
LCD_out_char_end:
ret

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

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

FBD5_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 FBD5 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD6_
#define _FBD6_ FBD6
#message define FBD6 (ADC_in)__FILE__

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



FBD6_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  FBD6_end                          //Адрес MUX не соответствует


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

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



#else 
 #error redeclared FBD6  __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD7_
#define _FBD7_ FBD7
#message define FBD7 (integer in range)__FILE__

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

FBD7_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg_Load_Uz1              ;вход 

 rcall Read_cfg                       ;минимум  Lw
  mov   A, Addr_Data                  ;минимум  Lw
  rcall Read_cfg                      ;минимум  Hg
  mov   B, Addr_Data                  ;минимум  Hg

  rcall Read_cfg                      ;максимум  Lw
  mov   C, Addr_Data                  ;максимум  Lw
  rcall Read_cfg                      ;максимум  Hg
  mov   D, Addr_Data                  ;максимум  Hg
  
//============= Логика работы FBD блока ==================
  clr  Uz2H                            ;Предварительная установка
  clr  Uz2L                            ;Предварительная установка

  cp   Uz1L, C                         ;Вычитание
  cpc  Uz1H, D                         ;Вычитание
  brcc FBD7_zero
 
  cp   A, Uz1L                         ;Вычитание
  cpc  B, Uz1H                         ;Вычитание
  brcc FBD7_zero

  inc  Uz2L                            ;максимум > вход > минимум
FBD7_zero:
//============= Сохраняем результат  ==================
 rcall Read_cfg_Save_Uz2               ;Сохраняем результат
 ret;

#else 
 #error redeclared FBD7 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD8_
#define _FBD8_ FBD8
#message define FBD8 __FILE__

FBD8_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;

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

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

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

FBD8_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 FBD8 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD9_
#define _FBD9_ FBD9
#message define FBD9 (LCD_out_logic)__FILE__

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


FBD9_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg_Load_Uz1    //вход 1 
 rcall Read_cfg             //Позиция для записи
 mov   H, Addr_Data         //Позиция для записи 
//============= Логика работы FBD блока ==================
 mov  A, YL                 //Сохраняем Y
 mov  B, YH                 //Сохраняем Y
 ldi  G, 5                  //Количество байт для копирования
 and  Uz1L, One             //and
 breq FBD9_Zero            //Текст высокого состояния
 adiw YL, 5
FBD9_Zero:

 sub G, One                  //Перенос слова
 brcs  FBD9_End_copy        //Перенос слова
 rcall Read_cfg              //Извлекаем символ
 tst   Addr_Data             //Проверка окончания строки
 breq  FBD9_End_copy        //Проверка окончания строки  
 mov   ZL, H                 //Указатель позиции записи
 rcall LCD_out_char          //Выводим символ
 inc   H                     //Сдвиг позиции вывода
 rjmp  FBD9_Zero            //Перенос слова
FBD9_End_copy:
 mov  YL, A                 //Востановливаем Y
 mov  YH, B                 //Востанавливаем Y
 ADIW YL, 10                //пропускаем 10 байт конфигурации
 ret;


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

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

FBD10_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 FBD10_zero
 inc  Uz3L                            ;Uz1>Uz2
FBD10_zero:
//============= Сохраняем результат  ==================
 rcall Read_cfg_Save_Uz3                                   ;Сохраняем результат
 ret;

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

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

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

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

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

FBD12_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 FBD12 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD13_
#define _FBD13_ FBD13
#message define FBD13 (NOT)__FILE__

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

FBD13_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 FBD13 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD14_
#define _FBD14_ FBD14
#message define FBD14 (AND3)__FILE__

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

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

#else 
 #error redeclared FBD14 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD15_
#define _FBD15_ FBD15
#message define FBD15 time CTN
;Размер FBD блока
;1 байт  -вход U (логический)
;1 байт  -вход D (логический)
;1 байт  -вход R (логический)
;1 байт  -вход N (дискретный)
;1 байт  -выход Q (дискретный)
;2 байта -начальное значение счетчика
;Оперативная память:
;  1 байт  - состояние входа U, D (бит 7,6)
;  2 байта - значение счетчика

FBD15_init:     
 ADIW  YL, 5                                      ;пропускаем первые пять байт конфигурации
 ldi   A, 0b11000000                              ;начальное состояние входов
 st    X+, Addr_Data                              ;Сохраняем начальное состояние входов
 rcall Read_cfg                                   ;Читаем начальное начальное состояние
 st    X+, Addr_Data                              ;Сохраняем начальное начальное состояние  Lw
 rcall Read_cfg                                   ;Читаем начальное начальное состояние   
 st    X+, Addr_Data                              ;Сохраняем начальное начальное состояние Hg
 ret                                              ;Окончание инициализации блока      

FBD15_run:
//************* Читаем оперативную память *******************
  ld    A,    X+                                   ;читаем байт состояния
  ld    Uz3L, X+                                   ;отсечка времени Lw
  ld    Uz3H, X+                                   ;отсечка времени Hw
//************* Читаем состояние входов *********************
  rcall Read_cfg_Load_Uz1                          ;вход U
  rcall Read_cfg_Load_Uz2                          ;вход D
//***************** Отслеживаем сигнал U ********************
  bst  A, 7
  sbrs Uz1L, 0
  rjmp FBD15_no_U
  brts FBD15_no_U
  add  Uz3L, One         // Счетчик +1
  adc  Uz3H, Zero
  rjmp FBD15_no_D
//***************** Отслеживаем сигнал D ********************
FBD15_no_U:
  bst  A, 6
  sbrs Uz2L, 0
  rjmp FBD15_no_D
  brts FBD15_no_D
  sub  Uz3L, One         // Счетчик -1
  sbc  Uz3H, Zero
FBD15_no_D:
//*********** Сохраняем состояние входов ********************
  bst  Uz1L, 0
  bld  A, 7              // Вход U
  bst  Uz2L, 0
  bld  A, 6              // Вход D
//************* Читаем состояние входов *********************
  rcall Read_cfg_Load_Uz1                          ;вход R
  rcall Read_cfg_Load_Uz2                          ;вход N
//***************** Проверяем уровень R *********************
  sbrs Uz1L, 0
  rjmp FBD15_end
  mov  Uz3L, Uz2L
  mov  Uz3H, Uz2H
FBD15_end:
  SBIW  XL,  3               //Смещаем указатель на состояние
  st   X+,   A               //сохраняем
  st   X+,   Uz3L            //сохраняем
  st   X+,   Uz3H            //сохраняем
  rcall Read_cfg_Save_Uz3    //выводим состояние
  ADIW  YL,  2               //Пропускаем байты конфигурации
  ret 



#else 
 #error redeclared FBD15 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD16_
#define _FBD16_ FBD16
#message define FBD16 (Int16ToSingl)__FILE__

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

//Подключаем описание функций сложения вычитания
#define _real_Int16ToReal_fun_

FBD16_run:
//===== Читаем данные блока из файла конфигураций ===== 
 rcall Read_Cfg_Load_Uz1    //Целое число Int16
//============= Логика работы FBD блока =============== 
 rcall real_Int16ToReal     //Преобразование
//============= Сохраняем результат  ==================    
  mov Uz1L, XL              //Передаем указатель
  mov Uz1H, XH              //Передаем указатель
  rcall Read_cfg_Save_Uz1   //Передаем указатель
  st    X+, D               //Сохраняем результат
  st    X+, C               //Сохраняем результат
  st    X+, B               //Сохраняем результат
  st    X+, A               //Сохраняем результат
 ret

#else 
 #error redeclared FBD16 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD17_
#define _FBD17_ FBD17
#message define FBD17 (LCD_out_real)__FILE__

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


FBD17_run:
//======== Читаем данные блока из файла конфигураций ========= 
 rcall Read_cfg_Load_Uz1    //Указатель на вещественное число
 rcall Read_cfg             //Позиция для записи 
 mov   H, Addr_Data         //Позиция для записи
 rcall Read_cfg             //Количество символов
 mov   G, Addr_Data         //Количество символов
//============= Логика работы FBD блока ==================
  rcall bcdfp               //Вызов функции преобразования
  ret;



#else 
 #error redeclared FBD17 __FILE__
#endif
//============================================
 ;Сдвиг целой части               
shift_CBAFED_G:   
        lsl C
        rol B
        rol A
        rol F
        rol E
        rol D
        dec G
        brne shift_CBAFED_G 
        ret
;сдвиг дробной части
shift_ABC_G:
        lsr A
        ror B
        ror C
        dec G
        brne shift_ABC_G 
        ret

out_G_LCD_pos_H_inc:
      andi G,  $0f
      subi G,  0xD0
      brtc out_char_G_LCD_pos_H_inc   //Проверка вывода первого символа 
      cpi  G, 0x30                    //Проверка вывода первого символа
      brne out_char_G_LCD_pos_H_inc
      ret
out_char_G_LCD_pos_H_inc:
      clt 
      mov  Addr_Data, G
      mov  ZL, H
      rcall LCD_out_char      
      inc  H
      dec  Uz1L
      brne LCD_out_char_no_complet
      pop  G               //Извлекаем указатель
      pop  G               //Извлекаем указатель
LCD_out_char_no_complet:
      ret

//============================================

bcdfp: 
        mov ZL, Uz1L        //Загружаем вещественное число
        mov ZH, Uz1H        //Загружаем вещественное число
        mov Uz1L, G         //Количество выводимых символов
        ld  C,  Z+          //Загружаем вещественное число
        ld  B,  Z+          //Загружаем вещественное число
        ld  A,  Z+          //Загружаем вещественное число
        ld  G,  Z+          //Загружаем вещественное число
;Преобразование числа
        bst  G, 7            //В бит T сохраняем знак
        ori  G, $80          //
        lsl  A               // ABC- мантиса числа
        rol  G               //
        ror  A               //
        subi G, 126          // G - степень
;очистка памяти
        clr D
        clr F
        clr E  
;Сдвиг регистров (выделене целой и дробной части)
        tst  G
        breq  Next_real_LCD    
        mov   Addr_Data, G
        sbrs  Addr_Data, 7               //Сдвиг целой части 
        rcall shift_CBAFED_G             //Сдвиг целой части
        neg   G
        sbrc  Addr_Data, 7               //Сдвиг дробной части 
        rcall shift_ABC_G                //Сдвиг дробной части
Next_real_LCD:
;Выводим знак
        brtc LCD_real_no_negative_sign   //Выводим знак
        ldi  G, 0x2D                     //Выводим знак
        rcall out_char_G_LCD_pos_H_inc   //Выводим знак
LCD_real_no_negative_sign:
;bcd-преобразование целой части
        set   

        ldi     G,    -1
int_loop_1:
        inc     G
        subi    F, low(100000)
        sbci    E, byte2(100000)
        sbci    D, byte3(100000)
        brsh    int_loop_1
        subi    F, low(-100000)
        sbci    E, byte2(-100000)
        sbci    D, byte3(-100000)
        rcall   out_G_LCD_pos_H_inc   //Выводим символ

        ldi     G,    -1
int_loop_2:
        inc     G
        subi    F, low(10000)
        sbci    E, byte2(10000)
        sbci    D, byte3(10000)
        brsh    int_loop_2
        subi    F, low(-10000)
        sbci    E, byte2(-10000)
        sbci    D, byte3(-10000)
        rcall   out_G_LCD_pos_H_inc   //Выводим символ

        ldi     G,    -1
int_loop_3:
        inc     G
        subi    F, low(1000)
        sbci    E, byte2(1000)
        brsh    int_loop_3
        subi    F, low(-1000)
        sbci    E, byte2(-1000)
        rcall   out_G_LCD_pos_H_inc   //Выводим символ

        ldi     G,    -1
int_loop_4:
        inc     G
        subi    F, 100 
        sbci    E, byte2(100) 
        brsh    int_loop_4
        subi    F, -100 
        sbci    E, byte2(-100) 
        rcall   out_G_LCD_pos_H_inc   //Выводим символ

        ldi     G,    -1
int_loop_5:
        inc     G
        subi    F, 10
        brsh    int_loop_5 
        subi    F, -10 
        rcall   out_G_LCD_pos_H_inc   //Выводим символ
      
        mov  G,  F
        clt	 
        rcall   out_G_LCD_pos_H_inc   //Выводим символ
        clr F
;Выводим точку
        ldi  G, 0x2E                     //Выводим точку
        rcall out_char_G_LCD_pos_H_inc   //Выводим точку
;bcd-преобразование дробной части 
f_conv: 
       ldi G, 24
f_conv1: 
       lsr A
       ror B
       ror C
       ror D
       ror E
       ror F
         
      sbrc F,7
      subi F,$30
      sbrc F,3
      subi F,$03
      sbrc E,7
      subi E,$30
      sbrc E,3
      subi E,$03
      sbrc D,7
      subi D,$30
      sbrc D,3
      subi D,$03

      dec G
      brne f_conv1          

;распаковка bcd-представления дробной части
      mov G,  D
      swap G 
      rcall out_G_LCD_pos_H_inc
      mov G, D
      rcall out_G_LCD_pos_H_inc
      mov  G,E
      swap G 
      rcall out_G_LCD_pos_H_inc
      mov  G,E
      rcall out_G_LCD_pos_H_inc
      mov G,F
      swap G  
      rcall out_G_LCD_pos_H_inc
      mov G, F
      rcall out_G_LCD_pos_H_inc 
      ret
//********************************************************************************************************
#ifndef _FBD18_
#define _FBD18_ FBD18
#message define FBD18 (T trigger)__FILE__

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

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

FBD18_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 на С
 eor   A, One                      //Меняем состояние триггера 
 mov  Uz3L, A                      //Копируем текущее состояние
//============= Сохраняем результат  ==================
 sbiw  XL, 2                       //Сохраняем
 st X+, UZ2L                       //Сохраняем
 st X+, A                          //Сохраняем
 rcall Read_cfg_Save_Uz3           //Сохраняем результат
 ADIW  YL, 1                       //пропускаем байт конфигурации
 ret;

#else 
 #error redeclared FBD18 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD19_
#define _FBD19_ FBD19
#message define FBD19 __FILE__

FBD19_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;

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

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

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

FBD19_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 FBD19 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD20_
#define _FBD20_ FBD20
#message define FBD20 (AND4)__FILE__

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

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

#else 
 #error redeclared FBD20 __FILE__
#endif
//********************************************************************************************************
#ifndef _FBD21_
#define _FBD21_ FBD21
#message define FBD21 (shift left)__FILE__

//Размер описания FDB блока 11 байта
//1 байт- состояние при сбросе
//1 байт- вход shift left
//1 байт- вход reset
//1 байт- выход 0
//1 байт- выход 1
//1 байт- выход 2
//1 байт- выход 3
//1 байт- выход 4
//1 байт- выход 5
//1 байт- выход 6
//1 байт- выход 7
//Оперативная память 2 байт
//1 байт состояние сдвигового регистра
//1 байт состояние входа S в предыдущем цикле

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

FBD21_run:
//======== Читаем данные блока ========= 
 rcall Read_cfg                     //Читаем начальное состояние сдвигового регистра
 mov   C, Addr_Data                 //начальное состояние сдвигового регистра
 rcall Read_cfg_Load_Uz1            //вход shift left
 rcall Read_cfg_Load_Uz2            //вход reset
 ld    A,  X+                       //состояние сдвигового регистра
 ld    B,  X+                       //состояние входа shift в предыдущем цикле
//============= Логика работы FBD блока ==================
 mov   D, A

 eor   B, UZ1L                     //Проверка перехода 0-1 на shift up
 and   B, UZ1L                     //Проверка перехода 0-1 на shift up

 lsl   D                           //C=D[7]
 sbrc  B, 0                        //Проверка перехода 0-1 на shift up
 rol   A                           //Был переход сдвигаем

 sbrc UZ2L, 0                      //Проверка 1 на reset
 mov  A, C                         //Устанавливаем начальное состояние сдвигового регистра

  BST A, 0
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 0
  BST A, 1
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 1
  BST A, 2
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 2
  BST A, 3
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 3
  BST A, 4
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 4
  BST A, 5
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 5
  BST A, 6
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 6
  BST A, 7
  BLD Uz2L, 0
  rcall Read_cfg_Save_Uz2          //Вывод 7

//============= Сохраняем ОЗУ  ==================
  SBIW  XL, 2                                      //Смещаем указатель на состояние
  st   X+, A                                       //Сохраняем состояние сдвигового регистра
  st   X+, UZ1L                                    //Сохраняем входа shift в предыдущем цикле

ret;

#else 
 #error redeclared FBD21 __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  0x80, 0x40                                    //f:2 m:0  ADC_ATmega8a_v1_conf.inc
FBD1:  .DB  0x00, 0x0A, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00 //f:8 m:3  logic_generator_16.inc
FBD2:  .DB  0x83, 0x03                                    //f:2 m:0  time_counter_milliseconds.inc
FBD3:  .DB  0x05, 0x13                                    //f:2 m:0  port_C.inc
FBD4:  .DB  0x22, 0x2C, 0x10, 0x01, 0x04, 0x0C, 0x57, 0x49, 0x52, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2D, 0x2D, 0x2D, 0x2D, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x20, 0x2D, 0x2D, 0x2D, 0x2D, 0x00, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 //f:48 m:2  LCD_hd44780_2x16.inc
FBD5:  .DB  0x3F, 0x00, 0x1E, 0x00                        //f:3 m:0  const.inc
FBD6:  .DB  0x20, 0x00                                    //f:2 m:0  ADC_ATmega8a_v1_pin.inc
FBD7:  .DB  0x20, 0x8F, 0x02, 0x20, 0x03, 0x22            //f:6 m:0  integer_in_range.inc
FBD8:  .DB  0x52, 0x03, 0x25, 0x00                        //f:3 m:0  const.inc
FBD9:  .DB  0x11, 0x27                                    //f:2 m:0  port_C.inc
FBD10: .DB  0x2A, 0x02                                    //f:2 m:0  ADC_ATmega8a_v1_pin.inc
FBD11: .DB  0x2C, 0x64, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00 //f:8 m:3  logic_generator_16.inc
FBD12: .DB  0x08, 0x17                                    //f:2 m:0  port_B.inc
FBD13: .DB  0x09, 0x16                                    //f:2 m:0  port_B.inc
FBD14: .DB  0x0A, 0x15                                    //f:2 m:0  port_B.inc
FBD15: .DB  0x0B, 0x14                                    //f:2 m:0  port_B.inc
FBD16: .DB  0x0D, 0x18                                    //f:2 m:0  port_B.inc
FBD17: .DB  0x0C, 0x19                                    //f:2 m:0  port_B.inc
FBD18: .DB  0x22, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x48, 0x4F, 0x52, 0x54 //f:12 m:0  LCD_out_logic.inc
FBD19: .DB  0x20, 0x25, 0x23, 0x00                        //f:3 m:0  integer_more.inc
FBD20: .DB  0x23, 0x22, 0x24, 0x00                        //f:3 m:0  logic_or.inc
FBD21: .DB  0x23, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x52, 0x45, 0x41, 0x4B //f:12 m:0  LCD_out_logic.inc
FBD22: .DB  0x24, 0x27, 0x26, 0x00                        //f:3 m:0  logic_and.inc
FBD23: .DB  0x2A, 0x25, 0x28, 0x00                        //f:3 m:0  integer_more.inc
FBD24: .DB  0x28, 0x29                                    //f:2 m:0  logic_not.inc
FBD25: .DB  0x29, 0x2C, 0x2B, 0x00                        //f:3 m:0  logic_and.inc
FBD26: .DB  0x0E, 0x2B                                    //f:2 m:0  port_B.inc
FBD27: .DB  0x26, 0x21                                    //f:2 m:0  logic_not.inc
FBD28: .DB  0x00, 0x21, 0x13, 0x1D                        //f:4 m:0  logic_3and.inc
FBD29: .DB  0x1D, 0x02                                    //f:2 m:0  logic_not.inc
FBD30: .DB  0x1D, 0x2D, 0x2D, 0x2D, 0x1A, 0x00, 0x00, 0x00 //f:7 m:3  time_CTN.inc
FBD31: .DB  0x1A, 0x1B                                    //f:2 m:4  real_Int16ToSingl.inc
FBD32: .DB  0x1B, 0x05, 0x02, 0x00                        //f:3 m:0  LCD_out_real.inc
FBD33: .DB  0x1A, 0x1E, 0x1C, 0x00                        //f:3 m:0  integer_more.inc
FBD34: .DB  0x1C, 0x08, 0x2E, 0x00, 0x00, 0x00, 0x00, 0x4F, 0x4B, 0x00, 0x00, 0x00 //f:12 m:0  LCD_out_logic.inc
FBD35: .DB  0x1C, 0x1F                                    //f:2 m:0  logic_not.inc
FBD36: .DB  0x02, 0x01, 0x00, 0x00                        //f:3 m:2  logic_T_trigger.inc
FBD37: .DB  0x01, 0x04                                    //f:2 m:0  logic_not.inc
FBD38: .DB  0x0C, 0x1F                                    //f:2 m:0  port_C.inc
FBD39: .DB  0x08, 0x01                                    //f:2 m:0  port_D.inc
FBD40: .DB  0x04, 0x03, 0x00, 0x00                        //f:3 m:2  logic_T_trigger.inc
FBD41: .DB  0x03, 0x06                                    //f:2 m:0  logic_not.inc
FBD42: .DB  0x09, 0x03                                    //f:2 m:0  port_D.inc
FBD43: .DB  0x06, 0x05, 0x00, 0x00                        //f:3 m:2  logic_T_trigger.inc
FBD44: .DB  0x05, 0x07                                    //f:2 m:0  logic_not.inc
FBD45: .DB  0x07, 0x08, 0x00, 0x00                        //f:3 m:2  logic_T_trigger.inc
FBD46: .DB  0x01, 0x03, 0x05, 0x08, 0x09, 0x00            //f:5 m:0  logic_4and.inc
FBD47: .DB  0x1D, 0x09, 0x12, 0x00                        //f:3 m:0  logic_and.inc
FBD48: .DB  0x0A, 0x05                                    //f:2 m:0  port_D.inc
FBD49: .DB  0x0B, 0x08                                    //f:2 m:0  port_D.inc
FBD50: .DB  0x01, 0x12, 0x2D, 0x0A, 0x0B, 0x0C, 0x0D, 0x2E, 0x2E, 0x2E, 0x2E, 0x00 //f:11 m:2  shift_l.inc
FBD51: .DB  0x0A, 0x0E                                    //f:2 m:0  logic_not.inc
FBD52: .DB  0x0B, 0x0F                                    //f:2 m:0  logic_not.inc
FBD53: .DB  0x0C, 0x10                                    //f:2 m:0  logic_not.inc
FBD54: .DB  0x0D, 0x11                                    //f:2 m:0  logic_not.inc
FBD55: .DB  0x0C, 0x0E                                    //f:2 m:0  port_D.inc
FBD56: .DB  0x0D, 0x0F                                    //f:2 m:0  port_D.inc
FBD57: .DB  0x0E, 0x10                                    //f:2 m:0  port_D.inc
FBD58: .DB  0x0F, 0x11                                    //f:2 m:0  port_D.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_conf.inc (0,10000000,01000000)
ldi   XL, Low(FBD_DATA_RAM+94)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+94)          // Указатель на оперативную память
ldi   YL, Low(FBD1*2)                    // Указатель на flash память
ldi   YH, High(FBD1*2)                   // Указатель на flash память
rcall FBD1_init                     //logic_generator_16.inc (1,0,10,10,0,0)
ldi   YL, Low(FBD2*2)                    // Указатель на flash память
ldi   YH, High(FBD2*2)                   // Указатель на flash память
rcall FBD2_init                     //time_counter_milliseconds.inc (2,899)
ldi   YL, Low(FBD3*2)                    // Указатель на flash память
ldi   YH, High(FBD3*2)                   // Указатель на flash память
rcall FBD3_init                     //port_C.inc (3,5,19)
ldi   XL, Low(FBD_DATA_RAM+97)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+97)          // Указатель на оперативную память
ldi   YL, Low(FBD4*2)                    // Указатель на flash память
ldi   YH, High(FBD4*2)                   // Указатель на flash память
rcall FBD4_init                     //LCD_hd44780_2x16.inc (4,00100010,00101100,00010000,00000001,00000100,00001100,"WIRE","---- world ----",20,21,22,23,24,25)
ldi   YL, Low(FBD6*2)                    // Указатель на flash память
ldi   YH, High(FBD6*2)                   // Указатель на flash память
rcall FBD6_init                     //ADC_ATmega8a_v1_pin.inc (6,32,0)
ldi   YL, Low(FBD9*2)                    // Указатель на flash память
ldi   YH, High(FBD9*2)                   // Указатель на flash память
rcall FBD3_init                     //port_C.inc (3,17,39)
ldi   YL, Low(FBD10*2)                   // Указатель на flash память
ldi   YH, High(FBD10*2)                  // Указатель на flash память
rcall FBD6_init                     //ADC_ATmega8a_v1_pin.inc (6,42,2)
ldi   XL, Low(FBD_DATA_RAM+99)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+99)          // Указатель на оперативную память
ldi   YL, Low(FBD11*2)                   // Указатель на flash память
ldi   YH, High(FBD11*2)                  // Указатель на flash память
rcall FBD1_init                     //logic_generator_16.inc (1,44,100,100,0,0)
ldi   YL, Low(FBD12*2)                   // Указатель на flash память
ldi   YH, High(FBD12*2)                  // Указатель на flash память
rcall FBD8_init                     //port_B.inc (8,8,23)
ldi   YL, Low(FBD13*2)                   // Указатель на flash память
ldi   YH, High(FBD13*2)                  // Указатель на flash память
rcall FBD8_init                     //port_B.inc (8,9,22)
ldi   YL, Low(FBD14*2)                   // Указатель на flash память
ldi   YH, High(FBD14*2)                  // Указатель на flash память
rcall FBD8_init                     //port_B.inc (8,10,21)
ldi   YL, Low(FBD15*2)                   // Указатель на flash память
ldi   YH, High(FBD15*2)                  // Указатель на flash память
rcall FBD8_init                     //port_B.inc (8,11,20)
ldi   YL, Low(FBD16*2)                   // Указатель на flash память
ldi   YH, High(FBD16*2)                  // Указатель на flash память
rcall FBD8_init                     //port_B.inc (8,13,24)
ldi   YL, Low(FBD17*2)                   // Указатель на flash память
ldi   YH, High(FBD17*2)                  // Указатель на flash память
rcall FBD8_init                     //port_B.inc (8,12,25)
ldi   YL, Low(FBD26*2)                   // Указатель на flash память
ldi   YH, High(FBD26*2)                  // Указатель на flash память
rcall FBD8_init                     //port_B.inc (8,14,43)
ldi   XL, Low(FBD_DATA_RAM+102)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+102)         // Указатель на оперативную память
ldi   YL, Low(FBD30*2)                   // Указатель на flash память
ldi   YH, High(FBD30*2)                  // Указатель на flash память
rcall FBD15_init                    //time_CTN.inc (15,29,45,45,45,26,0)
ldi   XL, Low(FBD_DATA_RAM+109)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+109)         // Указатель на оперативную память
ldi   YL, Low(FBD36*2)                   // Указатель на flash память
ldi   YH, High(FBD36*2)                  // Указатель на flash память
rcall FBD18_init                    //logic_T_trigger.inc (18,2,1,0)
ldi   YL, Low(FBD38*2)                   // Указатель на flash память
ldi   YH, High(FBD38*2)                  // Указатель на flash память
rcall FBD3_init                     //port_C.inc (3,12,31)
ldi   YL, Low(FBD39*2)                   // Указатель на flash память
ldi   YH, High(FBD39*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,8,1)
ldi   XL, Low(FBD_DATA_RAM+111)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+111)         // Указатель на оперативную память
ldi   YL, Low(FBD40*2)                   // Указатель на flash память
ldi   YH, High(FBD40*2)                  // Указатель на flash память
rcall FBD18_init                    //logic_T_trigger.inc (18,4,3,0)
ldi   YL, Low(FBD42*2)                   // Указатель на flash память
ldi   YH, High(FBD42*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,9,3)
ldi   XL, Low(FBD_DATA_RAM+113)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+113)         // Указатель на оперативную память
ldi   YL, Low(FBD43*2)                   // Указатель на flash память
ldi   YH, High(FBD43*2)                  // Указатель на flash память
rcall FBD18_init                    //logic_T_trigger.inc (18,6,5,0)
ldi   XL, Low(FBD_DATA_RAM+115)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+115)         // Указатель на оперативную память
ldi   YL, Low(FBD45*2)                   // Указатель на flash память
ldi   YH, High(FBD45*2)                  // Указатель на flash память
rcall FBD18_init                    //logic_T_trigger.inc (18,7,8,0)
ldi   YL, Low(FBD48*2)                   // Указатель на flash память
ldi   YH, High(FBD48*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,10,5)
ldi   YL, Low(FBD49*2)                   // Указатель на flash память
ldi   YH, High(FBD49*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,11,8)
ldi   XL, Low(FBD_DATA_RAM+117)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+117)         // Указатель на оперативную память
ldi   YL, Low(FBD50*2)                   // Указатель на flash память
ldi   YH, High(FBD50*2)                  // Указатель на flash память
rcall FBD21_init                    //shift_l.inc (21,00000001,18,45,10,11,12,13,46,46,46,46)
ldi   YL, Low(FBD55*2)                   // Указатель на flash память
ldi   YH, High(FBD55*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,12,14)
ldi   YL, Low(FBD56*2)                   // Указатель на flash память
ldi   YH, High(FBD56*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,13,15)
ldi   YL, Low(FBD57*2)                   // Указатель на flash память
ldi   YH, High(FBD57*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,14,16)
ldi   YL, Low(FBD58*2)                   // Указатель на flash память
ldi   YH, High(FBD58*2)                  // Указатель на flash память
rcall FBD19_init                    //port_D.inc (19,15,17)
//========= run cycle ==========
Run_FBD:       //main cycle
ldi   YL, Low(FBD0*2)                    // Указатель на flash память
ldi   YH, High(FBD0*2)                   // Указатель на flash память
rcall FBD0_run                      //ADC_ATmega8a_v1_conf.inc (0,10000000,01000000)
ldi   XL, Low(FBD_DATA_RAM+94)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+94)          // Указатель на оперативную память
ldi   YL, Low(FBD1*2)                    // Указатель на flash память
ldi   YH, High(FBD1*2)                   // Указатель на flash память
rcall FBD1_run                      //logic_generator_16.inc (1,0,10,10,0,0)
ldi   YL, Low(FBD2*2)                    // Указатель на flash память
ldi   YH, High(FBD2*2)                   // Указатель на flash память
rcall FBD2_run                      //time_counter_milliseconds.inc (2,899)
ldi   YL, Low(FBD3*2)                    // Указатель на flash память
ldi   YH, High(FBD3*2)                   // Указатель на flash память
rcall FBD3_run                      //port_C.inc (3,5,19)
ldi   XL, Low(FBD_DATA_RAM+97)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+97)          // Указатель на оперативную память
ldi   YL, Low(FBD4*2)                    // Указатель на flash память
ldi   YH, High(FBD4*2)                   // Указатель на flash память
rcall FBD4_run                      //LCD_hd44780_2x16.inc (4,00100010,00101100,00010000,00000001,00000100,00001100,"WIRE","---- world ----",20,21,22,23,24,25)
ldi   YL, Low(FBD5*2)                    // Указатель на flash память
ldi   YH, High(FBD5*2)                   // Указатель на flash память
rcall FBD5_run                      //const.inc (5,63,30)
ldi   YL, Low(FBD6*2)                    // Указатель на flash память
ldi   YH, High(FBD6*2)                   // Указатель на flash память
rcall FBD6_run                      //ADC_ATmega8a_v1_pin.inc (6,32,0)
ldi   YL, Low(FBD7*2)                    // Указатель на flash память
ldi   YH, High(FBD7*2)                   // Указатель на flash память
rcall FBD7_run                      //integer_in_range.inc (7,32,655,800,34)
ldi   YL, Low(FBD8*2)                    // Указатель на flash память
ldi   YH, High(FBD8*2)                   // Указатель на flash память
rcall FBD5_run                      //const.inc (5,850,37)
ldi   YL, Low(FBD9*2)                    // Указатель на flash память
ldi   YH, High(FBD9*2)                   // Указатель на flash память
rcall FBD3_run                      //port_C.inc (3,17,39)
ldi   YL, Low(FBD10*2)                   // Указатель на flash память
ldi   YH, High(FBD10*2)                  // Указатель на flash память
rcall FBD6_run                      //ADC_ATmega8a_v1_pin.inc (6,42,2)
ldi   XL, Low(FBD_DATA_RAM+99)           // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+99)          // Указатель на оперативную память
ldi   YL, Low(FBD11*2)                   // Указатель на flash память
ldi   YH, High(FBD11*2)                  // Указатель на flash память
rcall FBD1_run                      //logic_generator_16.inc (1,44,100,100,0,0)
ldi   YL, Low(FBD12*2)                   // Указатель на flash память
ldi   YH, High(FBD12*2)                  // Указатель на flash память
rcall FBD8_run                      //port_B.inc (8,8,23)
ldi   YL, Low(FBD13*2)                   // Указатель на flash память
ldi   YH, High(FBD13*2)                  // Указатель на flash память
rcall FBD8_run                      //port_B.inc (8,9,22)
ldi   YL, Low(FBD14*2)                   // Указатель на flash память
ldi   YH, High(FBD14*2)                  // Указатель на flash память
rcall FBD8_run                      //port_B.inc (8,10,21)
ldi   YL, Low(FBD15*2)                   // Указатель на flash память
ldi   YH, High(FBD15*2)                  // Указатель на flash память
rcall FBD8_run                      //port_B.inc (8,11,20)
ldi   YL, Low(FBD16*2)                   // Указатель на flash память
ldi   YH, High(FBD16*2)                  // Указатель на flash память
rcall FBD8_run                      //port_B.inc (8,13,24)
ldi   YL, Low(FBD17*2)                   // Указатель на flash память
ldi   YH, High(FBD17*2)                  // Указатель на flash память
rcall FBD8_run                      //port_B.inc (8,12,25)
ldi   YL, Low(FBD18*2)                   // Указатель на flash память
ldi   YH, High(FBD18*2)                  // Указатель на flash память
rcall FBD9_run                      //LCD_out_logic.inc (9,34,11,"","SHORT")
ldi   YL, Low(FBD19*2)                   // Указатель на flash память
ldi   YH, High(FBD19*2)                  // Указатель на flash память
rcall FBD10_run                     //integer_more.inc (10,32,37,35)
ldi   YL, Low(FBD20*2)                   // Указатель на flash память
ldi   YH, High(FBD20*2)                  // Указатель на flash память
rcall FBD11_run                     //logic_or.inc (11,35,34,36)
ldi   YL, Low(FBD21*2)                   // Указатель на flash память
ldi   YH, High(FBD21*2)                  // Указатель на flash память
rcall FBD9_run                      //LCD_out_logic.inc (9,35,11,"","BREAK")
ldi   YL, Low(FBD22*2)                   // Указатель на flash память
ldi   YH, High(FBD22*2)                  // Указатель на flash память
rcall FBD12_run                     //logic_and.inc (12,36,39,38)
ldi   YL, Low(FBD23*2)                   // Указатель на flash память
ldi   YH, High(FBD23*2)                  // Указатель на flash память
rcall FBD10_run                     //integer_more.inc (10,42,37,40)
ldi   YL, Low(FBD24*2)                   // Указатель на flash память
ldi   YH, High(FBD24*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,40,41)
ldi   YL, Low(FBD25*2)                   // Указатель на flash память
ldi   YH, High(FBD25*2)                  // Указатель на flash память
rcall FBD12_run                     //logic_and.inc (12,41,44,43)
ldi   YL, Low(FBD26*2)                   // Указатель на flash память
ldi   YH, High(FBD26*2)                  // Указатель на flash память
rcall FBD8_run                      //port_B.inc (8,14,43)
ldi   YL, Low(FBD27*2)                   // Указатель на flash память
ldi   YH, High(FBD27*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,38,33)
ldi   YL, Low(FBD28*2)                   // Указатель на flash память
ldi   YH, High(FBD28*2)                  // Указатель на flash память
rcall FBD14_run                     //logic_3and.inc (14,0,33,19,29)
ldi   YL, Low(FBD29*2)                   // Указатель на flash память
ldi   YH, High(FBD29*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,29,2)
ldi   XL, Low(FBD_DATA_RAM+102)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+102)         // Указатель на оперативную память
ldi   YL, Low(FBD30*2)                   // Указатель на flash память
ldi   YH, High(FBD30*2)                  // Указатель на flash память
rcall FBD15_run                     //time_CTN.inc (15,29,45,45,45,26,0)
ldi   XL, Low(FBD_DATA_RAM+105)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+105)         // Указатель на оперативную память
ldi   YL, Low(FBD31*2)                   // Указатель на flash память
ldi   YH, High(FBD31*2)                  // Указатель на flash память
rcall FBD16_run                     //real_Int16ToSingl.inc (16,26,27)
ldi   YL, Low(FBD32*2)                   // Указатель на flash память
ldi   YH, High(FBD32*2)                  // Указатель на flash память
rcall FBD17_run                     //LCD_out_real.inc (17,27,5,2)
ldi   YL, Low(FBD33*2)                   // Указатель на flash память
ldi   YH, High(FBD33*2)                  // Указатель на flash память
rcall FBD10_run                     //integer_more.inc (10,26,30,28)
ldi   YL, Low(FBD34*2)                   // Указатель на flash память
ldi   YH, High(FBD34*2)                  // Указатель на flash память
rcall FBD9_run                      //LCD_out_logic.inc (9,28,8,".","OK")
ldi   YL, Low(FBD35*2)                   // Указатель на flash память
ldi   YH, High(FBD35*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,28,31)
ldi   XL, Low(FBD_DATA_RAM+109)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+109)         // Указатель на оперативную память
ldi   YL, Low(FBD36*2)                   // Указатель на flash память
ldi   YH, High(FBD36*2)                  // Указатель на flash память
rcall FBD18_run                     //logic_T_trigger.inc (18,2,1,0)
ldi   YL, Low(FBD37*2)                   // Указатель на flash память
ldi   YH, High(FBD37*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,1,4)
ldi   YL, Low(FBD38*2)                   // Указатель на flash память
ldi   YH, High(FBD38*2)                  // Указатель на flash память
rcall FBD3_run                      //port_C.inc (3,12,31)
ldi   YL, Low(FBD39*2)                   // Указатель на flash память
ldi   YH, High(FBD39*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,8,1)
ldi   XL, Low(FBD_DATA_RAM+111)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+111)         // Указатель на оперативную память
ldi   YL, Low(FBD40*2)                   // Указатель на flash память
ldi   YH, High(FBD40*2)                  // Указатель на flash память
rcall FBD18_run                     //logic_T_trigger.inc (18,4,3,0)
ldi   YL, Low(FBD41*2)                   // Указатель на flash память
ldi   YH, High(FBD41*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,3,6)
ldi   YL, Low(FBD42*2)                   // Указатель на flash память
ldi   YH, High(FBD42*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,9,3)
ldi   XL, Low(FBD_DATA_RAM+113)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+113)         // Указатель на оперативную память
ldi   YL, Low(FBD43*2)                   // Указатель на flash память
ldi   YH, High(FBD43*2)                  // Указатель на flash память
rcall FBD18_run                     //logic_T_trigger.inc (18,6,5,0)
ldi   YL, Low(FBD44*2)                   // Указатель на flash память
ldi   YH, High(FBD44*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,5,7)
ldi   XL, Low(FBD_DATA_RAM+115)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+115)         // Указатель на оперативную память
ldi   YL, Low(FBD45*2)                   // Указатель на flash память
ldi   YH, High(FBD45*2)                  // Указатель на flash память
rcall FBD18_run                     //logic_T_trigger.inc (18,7,8,0)
ldi   YL, Low(FBD46*2)                   // Указатель на flash память
ldi   YH, High(FBD46*2)                  // Указатель на flash память
rcall FBD20_run                     //logic_4and.inc (20,1,3,5,8,9)
ldi   YL, Low(FBD47*2)                   // Указатель на flash память
ldi   YH, High(FBD47*2)                  // Указатель на flash память
rcall FBD12_run                     //logic_and.inc (12,29,9,18)
ldi   YL, Low(FBD48*2)                   // Указатель на flash память
ldi   YH, High(FBD48*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,10,5)
ldi   YL, Low(FBD49*2)                   // Указатель на flash память
ldi   YH, High(FBD49*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,11,8)
ldi   XL, Low(FBD_DATA_RAM+117)          // Указатель на оперативную память
ldi   XH, High(FBD_DATA_RAM+117)         // Указатель на оперативную память
ldi   YL, Low(FBD50*2)                   // Указатель на flash память
ldi   YH, High(FBD50*2)                  // Указатель на flash память
rcall FBD21_run                     //shift_l.inc (21,00000001,18,45,10,11,12,13,46,46,46,46)
ldi   YL, Low(FBD51*2)                   // Указатель на flash память
ldi   YH, High(FBD51*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,10,14)
ldi   YL, Low(FBD52*2)                   // Указатель на flash память
ldi   YH, High(FBD52*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,11,15)
ldi   YL, Low(FBD53*2)                   // Указатель на flash память
ldi   YH, High(FBD53*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,12,16)
ldi   YL, Low(FBD54*2)                   // Указатель на flash память
ldi   YH, High(FBD54*2)                  // Указатель на flash память
rcall FBD13_run                     //logic_not.inc (13,13,17)
ldi   YL, Low(FBD55*2)                   // Указатель на flash память
ldi   YH, High(FBD55*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,12,14)
ldi   YL, Low(FBD56*2)                   // Указатель на flash память
ldi   YH, High(FBD56*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,13,15)
ldi   YL, Low(FBD57*2)                   // Указатель на flash память
ldi   YH, High(FBD57*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,14,16)
ldi   YL, Low(FBD58*2)                   // Указатель на flash память
ldi   YH, High(FBD58*2)                  // Указатель на flash память
rcall FBD19_run                     //port_D.inc (19,15,17)
rjmp  Run_FBD
.DSEG
RAM_global: .BYTE FBD_DATA_RAM-SRAM_START
RAM_uzel:   .BYTE 94
RAM_FBD:    .BYTE 25
RAM_stack:  .BYTE 8
