;====================================================================
; Main.asm file generated by New Project wizard
;
; Created:   Вт фев 26 2019
; Processor: ATmega8535
; Compiler:  AVRASM (Proteus)
;====================================================================

;====================================================================
; DEFINITIONS
;====================================================================

;====================================================================
; VARIABLES
;====================================================================

;====================================================================
; RESET and INTERRUPT VECTORS
;====================================================================

      ; Reset Vector
      rjmp  Start

;====================================================================
; CODE SEGMENT
;====================================================================
   .org $40
      arr:  .dw $FF50, $F170, $2070, $1802, $4502, $2025
   .org $52

   .equ K=4;
   .equ N=6;

; X - место в резидентной памяти программы
; R18 - Количество двухбайтовых элементнов
; R16 - Число К = Степени двойки
; Результат
; r21 - 2 часть числа
; r22 - 1 часть числа
AVERAGE:
   push R2
   in R2,sreg
   push R2
   push R3
   push R4
   push R5
   push R6
   push R7
   push R8
   push R16
   push R17
   push R18
   push R19
   push R20
   push R23
   push R24
   push R25

;==============================================
; Начало сортировки массива
;==============================================

   ; запоними текущуе место в РПД массива
   push Xl
   push Xh
   push R18

   ; Обозначим необходимые нам регистры именами
   .def CurrentX=R2
   .def IndexMaxElement = R3
   .def MaxElementHigh = R4
   .def MaxElementLow = R5
   .def CurrentIndexElement = R6
   .def CurrentElementHigh = R7
   .def CurrentElementLow = R8
   .def CountElement = R21

   MOV CurrentX, Xl

  ; Текущий индекс Элемента в РПД в R20
   MOV R20, Xl
SORT:
   ;Выполняем сортировку пузырьком
   ;загружаем количество элементов в память
   PUSH R18

   ; Получаем текущее Двухбайтовое число и думае что оно максимальное в массиве
   ld MaxElementHigh, X+
   ld MaxElementLow, X

   ; возращаем Х на первый элемент массива
   dec Xl

   ; Индекс текущего максимального числа
   mov IndexMaxElement, Xl

   ; Переходим к следующему двухбайтовому числу
   subi Xl, -2

   mov CurrentIndexElement, Xl

; Поиск максимального элемента в массиве
FIND_MAX:
   clc
   mov Xl, CurrentIndexElement

   ; Получаем текущее число в массиве
   ld CurrentElementHigh, X+
   ld CurrentElementLow, X

   dec Xl

   ; Производим сравнения старших байтов на равеснтво
   CPSE MaxElementHigh, CurrentElementHigh
   ; Производим сравнения Старших байтов
   CP MaxElementHigh, CurrentElementHigh
   brlo REPLACE_ELEMENT
   brsh NEXT_ITTERATION

   ; Сравниваем младшие байты
   CP MaxElementLow, CurrentElementLow
   BRLO REPLACE_ELEMENT

   rjmp NEXT_ITTERATION

REPLACE_ELEMENT:
   ; Производим обмен предыдущего максимального элемента с текущем
   mov MaxElementHigh, CurrentElementHigh
   mov MaxElementLow, CurrentElementLow

   ; Производим обмен Индексов предыдущего максимального элемента с текущем
   mov IndexMaxElement, CurrentIndexElement

NEXT_ITTERATION:
   ; Переходим к Следующему элемента массива
   inc currentIndexElement
   inc currentIndexElement

   dec R18

   brne  FIND_MAX

   ; Сравниваем индексы максимального элемента и текущего Элемента
   ; если он равны то переходим к следущему шагу
   ; иначе производим обмен в РПД
   CP IndexMaxElement, CurrentX
   breq NEXT_STEP

   ; производим обмен элементов в РПД
   mov Xl, CurrentX
   ld CurrentElementHigh, X+
   ld CurrentElementLow, X

   dec Xl

   st X, MaxElementHigh
   inc Xl
   st X, MaxElementLow

   mov Xl, IndexMaxElement

   st X, CurrentElementHigh
   inc Xl
   st X, CurrentElementLow

NEXT_STEP:
   ; Увеличиваем индекс и переходим к следующему числу в массиве
   inc CurrentX
   inc CurrentX

   mov Xl, currentX

   pop R18

   dec R18

   brne SORT

   ; Убераем обозначения индексов
   .undef CurrentX
   .undef IndexMaxElement
   .undef MaxElementHigh
   .undef MaxElementLow
   .undef CurrentElementHigh
   .undef CurrentElementLow
   .undef CurrentIndexElement
   .undef CountElement

   ; Достанем текущуе место в РПД массива
   pop R18
   pop Xh
   pop Xl

;==============================================
; Конец сортировки массива
;==============================================

   ldi r19, 2

   ; R17 Середина массива
   ; Делим на 2 и умножаем на два,
   ; Чтобы получить чётное число
   mov R17, R18
   lsr R17
   mul R17, R19
   mov R17, R0

   ; устанавливаем Адрес середины массива
   add Xl, R17

   ; Записываем степень двойки
   mov R17, R16

   ; Находим середину от неё
   lsr R17

   ; умножаем результат на два, так как у нас 16 разрядные числа
   mul R17, R19
   mov R17, R0
   ; Получаем адрес начала радиуса ранжировки
   SUB Xl, R17

   push R16
   ; R22 - Первое 8 разрядное число
   ; R21 - Второе 8 разрядное число
   ; R20 - Третье 8 разрядное число
   clr R20
   clr R21
   clr R22
SUM:
   clc
   ; Считываем пладший разряд
   subi Xl, -1
   ld R17, X

   ; Добавляем к необходимому разряду
   add R22,R17
   ; Проверяем переполнение
   brcs OVERFLOW_BIT_1

   rjmp NEXT_BYTE_2

OVERFLOW_BIT_1:
   inc r21
   clc

NEXT_BYTE_2:
   ; Загружаме старший разряд числа
   dec xl
   ld r17, x

   ; Добавляем к рязряду по середине
   add r21, r17
   ; Проверка переполнения
   brcs OVERFLOW_BIT_2

   rjmp NEXT_BYTE_3

OVERFLOW_BIT_2:
   inc R20
   clc

NEXT_BYTE_3:
   subi xl, -2

   dec R16
   brne sum
   POP R16

;==============================================
; Деление 3-байтового числа
;==============================================

; R22 - Первое 8 разрядное число
; R21 - Второе 8 разрядное число
; R20 - Третье 8 разрядное число
; R19 - делитель

   ldi r23, 2
   ldi R24, 1
   ldi r25, 0

   Mov R19, R16

; Определяем степень двойки
POW_TWO:
   ; Если они равны, то степень двойки найдена
   cp R24, R19
   brsh DIVISION

   mul R24, R23
   mov R24, R0
   inc R25

   rjmp POW_TWO

; Выполняем сдвиги 3 байтового числа
DIVISION:
   lsr r20
   brcs BYTE_IS_ONE
   brcc BYTE_IS_ZERO

BYTE_IS_ONE:
   seh
   lsr r21
   brcs BYTE_IS_ONE_2
   brcc BYTE_IS_ZERO_2

BYTE_IS_ZERO:
   clh
   clt
   lsr R21
   brcs BYTE_IS_ONE_2
   brcc BYTE_IS_ZERO_2

BYTE_IS_ONE_2:
   lsr R22
   set
   bld R22, 7

   rjmp EXIT_DIVISION

BYTE_IS_ZERO_2:
   lsr R22

EXIT_DIVISION:
   brhs BYTE_IS_ZERO_3
   brhc THE_END

BYTE_IS_ZERO_3:
   set
   bld R21, 7

THE_END:
   dec r25
   brne DIVISION

;==============================================
; Конец Деления 3 байтового чсила
;==============================================

EXIT:
   pop R25
   pop R24
   pop R23
   pop R20
   pop R19
   pop R18
   pop R17
   pop R16
   pop R8
   pop R7
   pop R6
   pop R5
   pop R4
   pop R3
   pop R2
   out sreg, R2
   pop R2
   ret

Start:
   ldi r16, high(ramend)
   out sph, r16

   ldi r16, low(ramend)
   out spl, r16

   ldi r18,N

   ldi xl, $60; Начальный адрес в РПД
   ldi zh, high(arr<<1); Загрузка адреса массива в памяти данных
   ldi zl, low(arr<<1); и сдвиг влево

INPIT_RPD:
   lpm R2, Z+; Запись массива в РПД
   lpm R3, Z+
   st X+, R3
   st X+, R2
   dec R18
   brne INPIT_RPD

   ldi R16, k
   ldi R18, N

   ldi Xl, $60

   RCall Average


Loop:
      rjmp  Loop