Исследование принципа работы циклических алгоритмов в PIC-контроллерах
Оценка 4.6

Исследование принципа работы циклических алгоритмов в PIC-контроллерах

Оценка 4.6
doc
08.05.2020
Исследование принципа работы циклических алгоритмов в PIC-контроллерах
11. Исследование принципа работы циклических алгоритмов в PIC-контроллерах.doc

ЛАБОРАТОРНАЯ РАБОТА № 2

Тема: Исследование принципа работы циклических алгоритмов в PIC-контроллерах

 

Цель: получение навыков организации программ для микроконтроллеров, содержащих циклы.

 

1 Сведения из теории

 

Микроконтроллеры являются управляющими устройствами, принимающими информацию с датчиков управляемого устройства, обрабатывающими ее и выдающими соответствующие управляющие сигналы. Эти действия циклически повторяются, поэтому циклы представляют собой неотъемлемую часть программ для микроконтроллеров.

Для организации циклически повторяющихся действий с известным числом повторений в контроллерах PIC используется пара команд:

DECFSZ   F, d

(DECrement  F, Skip if Zero), которая вычитает единицу из содержимого ячейки ОЗУ с адресом F и пропускает следующую команду, если в результате вычитания получился 0, d – признак приемника;

и GOTO <метка>, которая выполняет переход на команду с указанной меткой.

Циклическая часть алгоритма имеет следующую структуру:

 <переслать в счетчик число повторений цикла>

<метка>  <действия, которые необходимо повторять>

 <……………………………………………...>

 DECFSZ  <счетчик>, 1

 GOTO      <метка>

В качестве счетчика можно использовать любую ячейку ОЗУ с адресом, начиная с 0x0C.

Метка – любой идентификатор (слово, начинающееся с буквы).

Например, пусть требуется 8 раз добавить к аккумулятору число 10:

MOVLW .8

MOVWF 0x0C

CLRW

L1  ADDLW .10

DECFSZ 0x0C,1

GOTO L1

Цикл работает следующим образом. В регистр 0x0C помещаем число 8. Очищаем содержимое аккумулятора. Затем после каждого добавления к аккумулятору числа 10 вычитаем из регистра 0х0С единицу. Если при этом в регистре остается не 0, то выполняется следующая команда GOTO, которая возвращает управление на начало цикла (на команду с меткой). Если в результате получился 0 (а он получится через заданное число повторений, поскольку мы каждый раз вычитаем единицу), то команда перехода будет пропущена, и программа будет продолжать выполняться со следующей за GOTO команды. Таким образом, содержимое регистра, используемого в команде «DECFSZ», определяет, сколько раз будут повторяться команды в цикле.

Хотя циклически повторяться могут различные действия, изучить принципы организации циклов удобно на примерах перемножения содержимого двух регистров путем сложения значений одного из них число раз, соответствующее содержимому второго регистра. Например, чтобы 5 умножить на 4, можно 4 раза сложить 5, либо 5 раз сложить 4. Результат сложения должен накапливаться в какой-нибудь ячейке, которую будем называть накопителем. Содержимое накопителя до начала цикла должно быть равно нулю. На каждом шаге цикла к нему должно добавляться одно из перемножаемых значений, другое значение должно определять количество повторений.

Пример 1.

Пусть в регистре (0x0c) содержится значение 4, а в (0x1f) – значение 3.

Получить (0x0c)*(0x1f)→(w).

В этом случае аккумулятор является накопителем суммы, поэтому его начальное значение должно равняться нулю. Содержимое одного регистра будем добавлять к аккумулятору, с помощью другого будем отсчитывать повторения цикла.

Решение.

 

Команды

W

(0x0c)

(0x0d)

     clrw

0

4

3

L1 addwf 0x0c, 0

0+4

4

2

     Decfsz 0x0d, 1

0+4+4

4

1

     Goto L1

0+4+4+4

4

0

 

Примечание: в целях уменьшения размера таблицы результаты первых двух команд цикла показаны одной строкой.

Пример 2.

Получить (0x0c)*(0x1f)→(0x0c).

Решение. В этом случае сумма должна накапливаться в регистре 0x0c, поэтому его начальное состояние должно равняться нулю. Добавляться к нему будет значения аккумулятора, в котором должно храниться добавляемое. Поэтому сначала переместим содержимое регистра 0x0c в аккумулятор, затем очистим регистр.

 

Команды

W

(0x0c)

(0x0d)

    Movf  0x0c,0

4

4

3

    Clrf 0x0c

4

0

3

L1 addwf 0x0c, 1

4

0+4

2

     Decfsz 0x0d, 1

4

0+4+4

1

     Goto L1

4

0+4+4+4

0

 

Пример 3.

Получить (0x0c)2→(0x0c).

Решение. Здесь понадобится дополнительный регистр, в который нужно скопировать содержимое ячейки, так как оно должно быть умножено само на себя. Скопируем содержимое регистра 0x0c через аккумулятор в регистр 0x0f. Теперь в аккумуляторе, регистре 0x0c и регистр 0x0f одно и то же значение. Далее очистим регистр 0x0c, так как в нем должна накапливаться сумма. Теперь можно в цикле, число повторений которого задается значением в регистре 0x0f добавлять к содержимому регистра 0x0c содержимое аккумулятора.

 

Команды

W

(0x0c)

(0x0f)

    Movf  0x0c,0

4

4

x

   Movwf 0x0f

4

4

4

    Clrf 0x0c

4

0

4

L1 addwf 0x0c, 1

4

0+4

3

     Decfsz 0x0f, 1

4

0+4+4

2

     Goto L1

4

0+4+4+4

1

 

4

0+4+4+4+4

0

 

2 Порядок выполнения работы

 

1 Наберите каждую из программ, соответствующую заданию, в MPLAB.

2 Проверьте правильность работы программы, задав регистрам значения.

3 Оформите отчет так, как это показано в примерах.

Варианты заданий находятся в табл. 2 приложения.

 

3 Содержание отчета

 

Отчет должен содержать общие принципы организации циклов, решения задач с трассировочными таблицами.

 

Таблица 2

 

Варианты заданий к лабораторной работе № 2.

 

Вариант 1

 (0x0c)*(0x0d) → a) (w); b) (0x0c);

c) (0x0d).

(0x0c)=5; (0x0c)2 → (0x0c)

(0x0c)=4; (0x0c)3→ (w)

3*(0x0c)+ 4*(0x0d) →  (w);

(7*(0x0c)2 – 9*(0x0d)–8)*3 → (w)

Вариант 2

 (0x0e)*(0x0f) →  a) (w); b) (0x0e); c) (0x0f).

(0x0e)=4; (0x0e)2 → (w)

(0x0e)=3; (0x0e)3→ (w)

4*(0x0e)+ 5*(0x0f) →  (w);

(2*(0x0e)2 + 3*(0x0f)–15)*5 → (w)

Вариант 3

 (0x1a)*(0x1b) →a) (w); b) (0x1a); c) (0x1b).

(0x1a)=7; (0x1a)2 → (0x1a)

(0x1a)=5; (0x1a)3→ (0x1a)

3*(0x1a)+ 2*(0x1b) →  (w)

(5*(0x1a)2 – 7*(0x1b)+6)*6 → (w)

Вариант 4

 (0x1f)*(0x20) → a) (w); b) (0x1f);  c) (0x20).

(0x1f)=8; (0x1f)2 → (0x1f)

(0x1f)=2; (0x1f)3→ (w)

3*(0x1f)+ 6*(0x20) →  (w);

5 (12*(0x1f)2 – 10*(0x20)–3)*4 → (w)

Вариант 5

 (0x22)*(0x21) → a) (w); b) (0x22); c) (0x21).

(0x22)=4; (0x22)2 → (0x22)

(0x22)=3; (0x22)3→ (0x22)

9*(0x22)+ 8*(0x21) →  (0x21);

(7*(0x22)2 +4*(0x21)–35)*5 → (w)

Вариант 6

 (0x28)*(0x29) → a) (w); b) (0x28); c) (0x29).

(0x28)=4; (0x28)2 → (w)

(0x28)=2; (0x28)3→ (w)

6*(0x28)+ 15*(0x29) →  (0x28);

(10*(0x28)2 – 20*(0x29)+80)*3→ (w)

Вариант 7

(0x1B)*(0x21)→а) (w); b) (0x1B); c) (0x21).

(0x1B)=5; (0x1B)2 → (0x1B)

(0x1B)=2; (0x1B)3→ (0x1B)

11*(0x1B)+ 4*(0x21) →  (0x21);

(6*(0x1B)2 +5*(0x21)–11)*12 → (w)

Вариант 8

 (0x0D)*(0x21) →  a) (w); b) (0x0D); c) (0x21).

(0x0D)=4; (0x0D)2 → (w)

(0x0D)=3; (0x0D)3→ (0x0D)

19*(0x0D)+ 5*(0x21) →  (w)

(3*(0x0D)2 –9*(0x21)–13)*8 → (w)

Вариант 9

 (0x2E)*(0x2F) → (w); b) (0x2E); c) (0x2F).

(0x2E)=4; (0x2E)2 → (0x2E)

(0x2E)=2; (0x2E)3→ (w)

20*(0x2E)+ 4*(0x2F) →  (0x2F);

(17*(0x2E)2 +3*(0x2F)–11)*13 → (w)

Вариант 10

 (0x18)*(0x1E) → a) (w); b) (0x18); c) (0x1E).

(0x18)=5; (0x18)2 → (w)

(0x18)=3; (0x18)3→ (0x18)

21*(0x18)+ 28*(0x1E) →  (w);

(4*(0x18)2 –7*(0x1E)–3)*15 → (w)

Вариант 11

 (0x0F)*(0x1F) → а) (w); b) (0x0F); c) (0x1F).

(0x0F)=5; (0x0F)2 → (w)

(0x0F)=4; (0x0F)3→ (0x0F)

15*(0x0F)+ 18*(0x1F) →  (0x1F);

(6*(0x0F)2 +20*(0x1F)–45)*6 → (w)

Вариант 12

(0x1D)*(0x0C) → а) (w); b) (0x1D); c) (0x0C).

(0x1D)=4; (0x1D)2 → (0x1D)

(0x1D)=4; (0x1D)3→ (w)

21*(0x1D)– 5*(0x0C) →  (w);

(4*(0x1D)2 –8*(0x0C)+5)*14 → (w)

Вариант 13

(0x0E)*(0x2D) → а) (w); b) (0x0E); c) (0x2D).

(0x0E)=3; (0x0E)2 → (w)

(0x0E)=4; (0x0E)3→ (w)

25*(0x0E)+ 13*(0x2D) →  (0x2D);

(16*(0x0E)2 +7*(0x2D)–22)*35 → (w)

Вариант 14

(0x25)*(0x23) → а) (w); b) (0x25); c) (0x23).

(0x25)=4; (0x25)2 → (w)

(0x25)=3; (0x25)3→ (0x25)

15*(0x25)+ 18*(0x23) →  (0x23);

(5*(0x25)2 +12*(0x23)+4)*16 → (w)

Вариант 15

 (0x29)*(0x19) → а) (w); b) (0x29); c) (0x19).

(0x29)=5; (0x29)2 → (0x29)

(0x29)=3; (0x29)3→ (0x29)

14*(0x29)– 15*(0x19) →  (w);

(16*(0x29)2 +22*(0x19)–40)*8 → (w)

Вариант 16

 (0x1C)*(0x11) → а) (w); b) (0x1C); c) (0x11).

(0x1C)=3; (0x1C)2 → (w)

(0x1C)=4; (0x1C)3→ (0x1C)

15*(0x1C)+ 18*(0x11) →  (0x11);

(8*(0x1C)2 +7*(0x11)–5)*16 → (w)

Вариант 17

(0x1B)*(0x0F) → а) (w); b) (0x1B); c) (0x0F).

(0x1B)=4; (0x1B)2 → (w)

(0x1B)=5; (0x1B)3→ (0x1B)

12*(0x1B)+ 17*(0x0F) →  (0x0F);

(13*(0x1B)2 +4*(0x0F)–22)*10 → (w)

Вариант 18

 (0x21)*(0x0E) → а) (w); b) (0x21); c) (0x0E).

(0x21)=5; (0x21)2 → (w)

(0x21)=2; (0x21)3→ (0x21)

25*(0x21)+ 28*(0x0E) →  (0x0E);

(3*(0x21)2 –28*(0x0E)–12)*17 → (w)

Вариант 19

 (0x29)*(0x22) → а) (w); b) (0x29); c) (0x22).

(0x29)=4; (0x29)2 → (w)

(0x29)=4; (0x29)3→ (0x29)

15*(0x29)+ 18*(0x22) →  (0x22);

(6*(0x29)2 +5*(0x22)–45)*6 → (w)

Вариант 20

(0x11)*(0x28) → а) (w); b) (0x11); c) (0x28).

(0x11)=3; (0x11)2 → (w)

(0x11)=3; (0x11)3→ (0x11)

31*(0x11)– 3*(0x28) →  (0x28);

(11*(0x11)2 +8*(0x28)+5)*7 → (w)

Вариант 21

 (0x13)*(0x0D) → a)(w); b) (0x13); c) (0x0D).

(0x13)=5; (0x13)2 → (0x13)

(0x13)=5; (0x13)3→ (w)

33*(0x13)+ 8*(0x0D) →  (0x0D);

(8*(0x13)2 –4*(0x0D)–15)*13 → (w)

Вариант 22

(0x2C)*(0x0C) → a)(w); b) (0x2C); c) (0x0C).

(0x2C)=5; (0x2C)2 → (w)

(0x2C)=3; (0x2C)3→ (0x2C)

14*(0x2C)– 11*(0x0C) →  (0x0C);

(3*(0x2C)2 +2*(0x0C)–43)*7 → (w)

Вариант 23

 (0x2A)*(0x1C) →a)(w); b) (0x2A); c) (0x1C).

(0x2A)=4; (0x2A)2 → (w)

(0x2A)=3; (0x2A)3→ (0x2A)

18*(0x2A)+ 11*(0x1C) →  (0x1C);

(24*(0x2A)2 +3*(0x1C)–14)*9 → (w)

Вариант 24

 (0x2C)*(0x1A) → a)(w); b) (0x2C); c) (0x1A).

(0x2C)=3; (0x2C)2 → (0x2C)

(0x2C)=4; (0x2C)3→ (0x2C)

16*(0x2C)– 8*(0x1A) →  (0x1A);

(4*(0x2C)2 +11*(0x1A)+4)*12 → (w)

Вариант 25

(0x1E)*(0x1D) → a)(w); b) (0x1E); c) (0x1D).

(0x1E)=5; (0x1E)2 → (w)

(0x1E)=4; (0x1E)3→ (0x1E)

32*(0x1E)+ 4*(0x1D) →  (w);

(21*(0x1E)2 –11*(0x1D)–16)*4 → (w)

Вариант 26

(0x21)*(0x27) →a)(w); b) (0x21);  c) (0x27).

(0x21)=4; (0x21)2 → (w)

(0x21)=4; (0x21)3→ (0x21)

21*(0x21)+ 5*(0x27) →  (0x27);

(20*(0x21)2 +3*(0x27)–34)*5 → (w)

Вариант 27

 (0x25)*(0x28) → а) (w); b) (0x25); c) (0x28).

(0x25)=3; (0x25)2 → (w)

(0x25)=4; (0x25)3→ (0x25)

5*(0x25)– 3*(0x28) →  (0x28);

(4*(0x25)2 +7*(0x28)–12)*5 → (w)

Вариант 28

(0x2B)*(0x1E) → a)(w); b) (0x2B); c) (0x1E).

(0x2B)=5; (0x2B)2 → (w)

(0x2B)=3; (0x2B)3→ (0x2B)

10*(0x2B)– 8*(0x1E) →  (w);

(7*(0x2B)2 –4*(0x1E)+45)*4 → (w)

Вариант 29

 (0x26)*(0x11) → а) (w); b) (0x26); c) (0x11).

(0x26)=3; (0x26)2 → (w)

(0x26)=5; (0x26)3→ (0x26)

18*(0x26)+ 19*(0x11) →  (0x11);

(16*(0x26)2 +13*(0x11)+6)*6 → (w)

Вариант 30

(0x20)*(0x11) → a)(w); b) (0x20); c) (0x11).

(0x20)=4; (0x20)2 → (0x20)

(0x20)=3; (0x20)3→ (0x20)

6*(0x20)– 4*(0x11) →  (w);

(8*(0x20)2 +11*(0x11)–26)*3 → (w)

 


Скачано с www.znanio.ru

ЛАБОРАТОРНАЯ РАБОТА № 2 Тема:

ЛАБОРАТОРНАЯ РАБОТА № 2 Тема:

GOTO команды. Таким образом, содержимое регистра, используемого в команде «

GOTO команды. Таким образом, содержимое регистра, используемого в команде «

Пример 3. Получить (0 x 0 c ) 2 →(0 x 0 c )

Пример 3. Получить (0 x 0 c ) 2 →(0 x 0 c )

Вариант 1 (0 x 0 c )*(0 x 0 d ) → a ) ( w ); b ) (0 x 0 c ); c)…

Вариант 1 (0 x 0 c )*(0 x 0 d ) → a ) ( w ); b ) (0 x 0 c ); c)…

Вариант 16 (0 x 1 C )*(0 x 11) → а) ( w ); b ) (0 x 1

Вариант 16 (0 x 1 C )*(0 x 11) → а) ( w ); b ) (0 x 1

Вариант 30 (0 x 20)*(0 x 11) → a )( w ); b ) (0 x 20); c ) (0 x 11)

Вариант 30 (0 x 20)*(0 x 11) → a )( w ); b ) (0 x 20); c ) (0 x 11)
Скачать файл