Администрация форума не несёт ответственности за достоверность информации и оставляет за собой право редактировать или в особых случаях даже удалять посты без предупреждения. Спасибо за понимание.

Программирование ATMEL в BASCOM.

Информация о пользователе

Привет, Гость! Войдите или зарегистрируйтесь.


Вы здесь » Программирование ATMEL в BASCOM. » Вопросы - ответы » Быстро очистить массив


Быстро очистить массив

Сообщений 1 страница 30 из 30

1

Нужно быстро очистить массив.
Делаю так:

Код:
Dim Picsel(128) As Byte 
   For I = 1 To 128
     Picsel(i) = 0
   Next I

Но так в конкретной ситуации медленно...
Не ту ли возможности очистить одной командой?
И ещё, если возможности нет, как это написать на АСМе?

0

2

Можно попробовать найти адрес начала массива командой varptr. Потом загнать этот адрес в регистр X. В регистр например R20 загоняем 0. Организуем цикл с количеством шагов равным длине массива и командой ST с постинкрементом регистра Х заносим в память значение регистра R20, т.е. 0.

0

3

'самое быстрое, но длинно (линейная программа)
$asm
    LDI R24 , 0                           '0
    Loadadr Picsel , X                  'указатель на начало массива в Z
                                                'записать 128 раз
    St Z+ , R24                          'записать 1
    St Z+ , R24                          'записать 2

    ...                                         'повторять 3...126

    St,Z+ , R24                          'записать 127
    St,Z+ , R24                          'записать 128
$end Asm

'вдвое медленней, но коротко (с циклом)
$asm
    LDI R24 , 0                           '0
    LDI R25 , 128                        '128
    Loadadr Picsel , X                  'указатель на начало массива в
Clar:
    St Z+ , R24                         'записать 128 раз
    Dec R25
    Brne Clar
$end Asm

0

4

Спасибо!
Проблема быстродействия важна во многих случаях.
Кроме оптимизации алгоритма и перехода на ASM наверняка есть определённые хитрости, позволяющие ускорить работу программы.
В основном это касается математики.
Например, вычитать необходимые байты с массива данных, произвести определённые преобразования, отправить в другой массив.
Один добрый человек сформулировал несколько моментов ускорения быстродействия:
1) X=X+1 работает быстрее, чем Incr X
2) X=0 быстрее, чем Reset X.
3) Циклы For...Next вообще лучше не применять, если скорость важна.
Может быть совместными усилиями сможем продолжить список?

0

5

radan написал(а):

Может быть совместными усилиями сможем продолжить список?

было бы не плохо

0

6

radan написал(а):

1) X=X+1 работает быстрее, чем Incr X

С этим непонятно, спорно, если компилятор правильно сделан (оптимизация), то Incr 8-бит должно быстрее работать и меньше занимать обычной опирации сложения любых чисел (ведь для сложения числа нужно указывать какое оно, а это + ещё такты процессора для считывания данных (как минимум)).
Вообще компилятор должен в любом случае оптимизировать эти два варианта, галочка в опциях стоит?

radan написал(а):

2) X=0 быстрее, чем Reset X.

По логике быстрее и экономнее должна выглядеть строка такого типа: X =X Xor X (надо конечно пробовать, как оно там в реале выглядит, ксор обычно 1 команда/такт).
И вообще, не забываем при инициализации использовать заранее известные значения для других переменных, например зщная, что Х у нас равен 0 (раньше установили), то можно дальше это использовать Y=X и т.д...

radan написал(а):

3) Циклы For...Next вообще лучше не применять, если скорость важна.

Тут по опыту и отзывам в инете могу сказать обратное, ибо на "do & loop" народ весьма сильно жалуется на стабильность работы. В исходном бесики, эти команды чуждые (пришли в поздних версиях, GW-BASIC 1983). Рекомендуют ими не пользоваться.

Вообще те люди, кто пользуются баскомом, должны отчетливо понимать, что за гибкость, удобство и скорость надо платить производительностью и тут главное только одно - надежность. Ясен пень, что если нужна производительность и экономия памяти, то проще в том же баскоме кодить на асме изначально, делать редкие вставки на бэйсике (некий обратный изврат).
По этому для каждого случая подход индивидуален и думаю лучше обсудить (впрочем это и так уже обсуждалось/известно) именно надежность и правила как надо делать (вон в преобразовании типов сколько косяков можно допустить в одной математики..).

Отредактировано RDW (2013-03-09 12:28:50)

0

7

radan написал(а):

...
Один добрый человек сформулировал несколько моментов ускорения быстродействия:
1) X=X+1 работает быстрее, чем Incr X
2) X=0 быстрее, чем Reset X.
3) Циклы For...Next вообще лучше не применять, если скорость важна.
Может быть совместными усилиями сможем продолжить список?

Что то сомнительно. Скорее всего компилятор даст одинаковый код для обоих вариантов. Быстрее всего делаются операции в регистрах. То есть если нужна скорость, например в прерывании, asm рулит тем, что все переменные переписываешь в регистры и работаешь с регистрами, в том числе и инкремент и проверки. Компилятор же может делать загрузку/выгрузку в регистры для каждого оператора.

0

8

компилятор генерировал одинаковый код для
1) X=X+1 работает быстрее, чем Incr X
2) X=0 быстрее, чем Reset X.
я проверял в предыдущей версии - надо было максимально в прерывании всё сделать

цикл for-next работал быстрее чем +1 -- я не помню, что в асме было, но факт

0

9

Вот такой код сгенерил BASCOM при компиляции кода
$hwstack = 40
$swstack = 40
$framesize = 50
$regfile = "m8def.dat"
$crystal = 12000000
Dim Picsel(128) As Byte
Dim I As Byte
   For I = 1 To 128
     Picsel(i) = 0
   Next I
End

Код:
10:          For I = 1 To 128
+0000002F:   E081        LDI     R24,0x01         Load immediate
+00000030:   938000E0    STS     0x00E0,R24       Store direct to data space
+00000032:   910000E0    LDS     R16,0x00E0       Load direct from data space
+00000034:   3800        CPI     R16,0x80         Compare with immediate
10:          For I = 1 To 128
+00000035:   F010        BRCS    PC+0x03          Branch if carry set
+00000036:   F009        BREQ    PC+0x02          Branch if equal
10:          For I = 1 To 128
+00000037:   C011        RJMP    PC+0x0012        Relative jump
11:            Picsel(i) = 0
+00000038:   E080        LDI     R24,0x00         Load immediate
+00000039:   EEA0        LDI     R26,0xE0         Load immediate
11:            Picsel(i) = 0
+0000003A:   E0B0        LDI     R27,0x00         Load immediate
+0000003B:   90AD        LD      R10,X+           Load indirect and postincrement
11:            Picsel(i) = 0
+0000003C:   24BB        CLR     R11              Clear Register
+0000003D:   E5AF        LDI     R26,0x5F         Load immediate
11:            Picsel(i) = 0
+0000003E:   E0B0        LDI     R27,0x00         Load immediate
+0000003F:   0DAA        ADD     R26,R10          Add without carry
11:            Picsel(i) = 0
+00000040:   1DBB        ADC     R27,R11          Add with carry
+00000041:   938C        ST      X,R24            Store indirect
12:          Next I
+00000042:   EEA0        LDI     R26,0xE0         Load immediate
+00000043:   E0B0        LDI     R27,0x00         Load immediate
12:          Next I
+00000044:   918C        LD      R24,X            Load indirect
+00000045:   5F8F        SUBI    R24,0xFF         Subtract immediate
12:          Next I
+00000046:   938C        ST      X,R24            Store indirect
+00000047:   F408        BRCC    PC+0x02          Branch if carry cleared
12:          Next I
+00000048:   CFE9        RJMP    PC-0x0016        Relative jump

Отредактировано sva-don (2013-03-10 20:07:22)

0

10

А вот сравнение I=0 и Reset I

Код:
9:        I = 0
+0000002F:   E080            LDI     R24,0x00         Load immediate
+00000030:   93800060    STS     0x0060,R24       Store direct to data space
10:       Reset I
+00000032:   91700060    LDS     R23,0x0060       Load direct from data space
10:       Reset I
+00000034:   7F7E           ANDI    R23,0xFE         Logical AND with immediate
+00000035:   93700060    STS     0x0060,R23       Store direct to data space

Прямое присвоение чуток эффективнее.  :flag:

Отредактировано sva-don (2013-03-09 22:38:29)

0

11

Ну и напоследок I=I+1 и Incr I

Код:
:       
9:        I = I + 1
+0000002F:   E6A0        LDI     R26,0x60         Load immediate
+00000030:   E0B0        LDI     R27,0x00         Load immediate
9:        I = I + 1
+00000031:   918C        LD      R24,X            Load indirect
+00000032:   5F8F        SUBI    R24,0xFF         Subtract immediate
9:        I = I + 1
+00000033:   938C        ST      X,R24            Store indirect

10:       Incr I
+00000034:   E6A0        LDI     R26,0x60         Load immediate
+00000035:   E0B0        LDI     R27,0x00         Load immediate
10:       Incr I
+00000036:   918C        LD      R24,X            Load indirect
+00000037:   5F8F        SUBI    R24,0xFF         Subtract immediate
10:       Incr I
+00000038:   938C        ST      X,R24            Store indirect

Как видим все совпало с точностью до запятой.  :cool:

Отредактировано sva-don (2013-03-09 22:37:34)

0

12

А вот код, сгенерированный из вот такого цикла.
Dim I(128) As Byte
Dim J As Byte
J = 1
Main:
I(j) = 0
Incr J
If J < 128 Then Goto Main

Код:
10:       J = 1
+0000002F:   E081        LDI     R24,0x01         Load immediate
+00000030:   938000E0    STS     0x00E0,R24       Store direct to data space
12:       I(j) = 0
+00000032:   E080        LDI     R24,0x00         Load immediate
+00000033:   EEA0        LDI     R26,0xE0         Load immediate
12:       I(j) = 0
+00000034:   E0B0        LDI     R27,0x00         Load immediate
+00000035:   90AD        LD      R10,X+           Load indirect and postincrement
12:       I(j) = 0
+00000036:   24BB        CLR     R11              Clear Register
+00000037:   E5AF        LDI     R26,0x5F         Load immediate
12:       I(j) = 0
+00000038:   E0B0        LDI     R27,0x00         Load immediate
+00000039:   0DAA        ADD     R26,R10          Add without carry
12:       I(j) = 0
+0000003A:   1DBB        ADC     R27,R11          Add with carry
+0000003B:   938C        ST      X,R24            Store indirect
13:       Incr J
+0000003C:   EEA0        LDI     R26,0xE0         Load immediate
+0000003D:   E0B0        LDI     R27,0x00         Load immediate
13:       Incr J
+0000003E:   918C        LD      R24,X            Load indirect
+0000003F:   5F8F        SUBI    R24,0xFF         Subtract immediate
13:       Incr J
+00000040:   938C        ST      X,R24            Store indirect
14:       If J < 128 Then Goto Main
+00000041:   910000E0    LDS     R16,0x00E0       Load direct from data space
14:       If J < 128 Then Goto Main
+00000043:   3800        CPI     R16,0x80         Compare with immediate
+00000044:   F008        BRCS    PC+0x02          Branch if carry set
14:       If J < 128 Then Goto Main
+00000045:   C001        RJMP    PC+0x0002        Relative jump
+00000046:   CFEB        RJMP    PC-0x0014        Relative jump

0

13

sva-don написал(а):

А вот сравнение I=0 и Reset I

А "I =I Xor I" не пробовали?

Отредактировано RDW (2013-03-10 11:20:51)

0

14

Ну давайте попробуем.

Код:
9:        I = 0
+0000002F:   E080        LDI     R24,0x00         Load immediate
+00000030:   93800060    STS     0x0060,R24       Store direct to data space

10:       Reset I
+00000032:   91700060    LDS     R23,0x0060       Load direct from data space
+00000034:   7F7E        ANDI    R23,0xFE         Logical AND with immediate
+00000035:   93700060    STS     0x0060,R23       Store direct to data space

11:       I=I xor I 
+00000037:   91000060    LDS     R16,0x0060       Load direct from data space
+00000039:   91400060    LDS     R20,0x0060       Load direct from data space
+0000003B:   2704        EOR     R16,R20          Exclusive OR
+0000003C:   E6A0        LDI     R26,0x60         Load immediate
+0000003D:   E0B0        LDI     R27,0x00         Load immediate
+0000003E:   930C        ST      X,R16            Store indirect

Сравниваем. Похоже, что ХОR явно проигрывает.

Отредактировано sva-don (2013-03-10 20:06:17)

0

15

Спасибо.
Мда...а если в асме писать, то ксор самый быстрый.  :D
Компилятор - не к черту.

Отредактировано RDW (2013-03-10 20:26:45)

0

16

radan написал(а):

Может быть совместными усилиями сможем продолжить список?

Вроде начинали такой список Оптимизация кода программ
от себя добавлю, что математические вычисления много съедают памяти в сравнении с логическими. К примеру, в известном датчике 18В20, все упорно сдвигают байт умножением на 16, хотя применение сдвига(шифт) заметно уменьшает объём программы.
И вопрос, как оптимально 2-х байтную переменную разложить по байтам. К примеру из FA4A сделать  FA и 4A

0

17

Легко делается оверлеями.

+1

18

Вы знаете, я уже давно пришел к выводу, что оптимизация по объему занимаемой памяти вещь бесполезная. Проще взять контроллер помощней и не заморачиваться. Например на Платане ATMega128 250.00 руб. за шт,
от 3  199.00 руб. за шт, от 21  179.41 руб. за шт. Не сочтите за рекламу, нашел первую попавшуюся цену. Думаю, что цена не очень кусачая. Прошли те времена, когда приходилось бороться за каждый байт. :crazyfun:
Что касается оптимизации быстродействия, то тут я конечно согласен. Иногда придется помучаться, чтобы выжать из МК все, что можно.

0

19

sva-don написал(а):

Прошли те времена, когда приходилось бороться за каждый байт. 
Что касается оптимизации быстродействия, то тут я конечно согласен. Иногда придется помучаться, чтобы выжать из МК все, что можно.

Согласен. Взял Мегу128, сделал на ней аналоговые и цифровые часы (DS1307) на матрицу светодиодов 16х60, термометр, связь с ПК. И всего занято 7%.
Теперь придумываю всякие эффекты - режимы. А вот для этого и хочется увеличить быстродействие.
Там куча математики, наверное придётся ассемблер изучать.

0

20

RDW написал(а):

Легко делается оверлеями.

Блин, всё просто!, а обратно, сложить из байтов двухбайтное, также?

Код:
Dim  S As Word
dim sb(2) as Byte at s overlay

Принимать в sb(2), а работать с   S?

0

21

Что будет быстрее работать -
набор If - Then
или select case?

0

22

Ну давайте протестируем и это.

Код:
9:        If a = 1 Then
+0000002F:   91000060    LDS       R16,0x0060     Load direct from data space
+00000031:   3001        CPI       R16,0x01       Compare with immediate
+00000032:   F009        BREQ      PC+0x02        Branch if equal
+00000033:   C003        RJMP      PC+0x0004      Relative jump
10:        a = 0
+00000034:   E080        LDI       R24,0x00       Load immediate
+00000035:   93800060    STS       0x0060,R24     Store direct to data space
14:      Select case a
14:        Case 1 : a = 0
+00000037:   91000060    LDS       R16,0x0060     Load direct from data space
+00000039:   3001        CPI       R16,0x01       Compare with immediate
+0000003A:   F009        BREQ      PC+0x02        Branch if equal
+0000003B:   C003        RJMP      PC+0x0004      Relative jump
+0000003C:   E080        LDI       R24,0x00       Load immediate
+0000003D:   93800060    STS       0x0060,R24     Store direct to data space

Все совпадает, разницы нет.  :flag:

Отредактировано sva-don (2013-03-11 13:50:46)

0

23

sva-don написал(а):

Ну давайте протестируем и это.

Как вы получаете ASM из Баскома?

0

24

radan написал(а):

Там куча математики, наверное придётся ассемблер изучать.

Знание ассемблера вещь весьма необходимая. Поэтому учиться, учиться и учиться... :canthearyou:

0

25

radan написал(а):

Как вы получаете ASM из Баскома?

Все просто, в AVR Studio открываю файл *.obj и затем в меню View выбираю Disassembler.
Можно порыться в инете и найти кучу дизассемблеров, но мне больше по душе Studio. Он в листинг еще и команды на Bascome вставляет, намного проще ориентироваться.

0

26

kip написал(а):

Блин, всё просто!, а обратно, сложить из байтов двухбайтное, также?
Код:

Dim  S As Word
dim sb(2) as Byte at s overlay

Принимать в sb(2), а работать с   S?

Делается всё легко в обе стороны, причем даже доп. объявлений делать не нужно:

Код:
Dim C As Word
Dim C0 As Byte At C + 0 Overlay
Dim C1 As Byte At C + 1 Overlay

Можно как в С помещать двухбайтное число и считывать по отдельности их побайтно в С0, С1, так и на оборот, заносим значений в С0, С1 и считываем сборку в С.
Более того, этот метод можно использовать, если нужно поменять местами старшый и младший байт + во всех других операциях (начиная от текста и заканчивая массивами).
В хелпе баскома эти примеры хорошо описаны...

0

27

RDW написал(а):

Спасибо.
Мда...а если в асме писать, то ксор самый быстрый. 
Компилятор - не к черту.

Отредактировано RDW (2013-03-10 21:26:45)

Компилятор конечно ступил, что второй раз не нужно грузить туже самую ячейку памяти в регистр и потом наоборот дважды в один и тот же адрес пихать разные регистры, оптимизатор должен был бы это просечь, но использование I = I XOR I довольно редкий программерский стиль в ЯВУ, ИМХО.
Чаще присваивают 0.

0

28

Студия сейчас недоступна, посмотрите код типа

Код:
Dim a as Byte
Dim B As Iram Byte

A = a + 1
if a > 250 then a = 0
B = B + 1
if B > 250 then B = 0

Удастся ли зарезервировать регистор для "сверхбыстрых" операций длиной в один байт?

0

29

Плиз сэр  8-)

Код:
10:       A = a + 1
+0000002F:   E6A0        LDI       R26,0x60       Load immediate
+00000030:   E0B0        LDI       R27,0x00       Load immediate
+00000031:   918C        LD        R24,X          Load indirect
+00000032:   5F8F        SUBI      R24,0xFF       Subtract immediate
+00000033:   938C        ST        X,R24          Store indirect
11:       if a > 250 then a = 0
+00000034:   91000060    LDS       R16,0x0060     Load direct from data space
+00000036:   3F0A        CPI       R16,0xFA       Compare with immediate
+00000037:   F010        BRCS      PC+0x03        Branch if carry set
+00000038:   F009        BREQ      PC+0x02        Branch if equal
+00000039:   C001        RJMP      PC+0x0002      Relative jump
+0000003A:   C003        RJMP      PC+0x0004      Relative jump
+0000003B:   E080        LDI       R24,0x00       Load immediate
+0000003C:   93800060    STS       0x0060,R24     Store direct to data space
12:       B = B + 1
+0000003E:   E0A8        LDI       R26,0x08       Load immediate
+0000003F:   E0B0        LDI       R27,0x00       Load immediate
+00000040:   918C        LD        R24,X          Load indirect
+00000041:   5F8F        SUBI      R24,0xFF       Subtract immediate
+00000042:   938C        ST        X,R24          Store indirect
13:       if B > 250 then B = 0
+00000043:   2D08        MOV       R16,R8         Copy register
+00000044:   EF4A        LDI       R20,0xFA       Load immediate
+00000045:   1704        CP        R16,R20        Compare
+00000046:   F010        BRCS      PC+0x03        Branch if carry set
+00000047:   F009        BREQ      PC+0x02        Branch if equal
+00000048:   C001        RJMP      PC+0x0002      Relative jump
+00000049:   C002        RJMP      PC+0x0003      Relative jump
+0000004A:   E080        LDI       R24,0x00       Load immediate
+0000004B:   2E88        MOV       R8,R24         Copy register

Тут про If B>25 then B=0 мне что то не совсем понятно, на всякий случай приведу полный код из студии.

Код:
:        $regfile = "m8def.dat"
+00000000:   C012        RJMP      PC+0x0013      Relative jump
+00000001:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+00000002:   9518        RETI                     Interrupt return
+00000003:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+00000004:   9518        RETI                     Interrupt return
+00000005:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+00000006:   9518        RETI                     Interrupt return
+00000007:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+00000008:   9518        RETI                     Interrupt return
+00000009:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+0000000A:   9518        RETI                     Interrupt return
+0000000B:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+0000000C:   9518        RETI                     Interrupt return
+0000000D:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+0000000E:   9518        RETI                     Interrupt return
+0000000F:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+00000010:   9518        RETI                     Interrupt return
+00000011:   9518        RETI                     Interrupt return
1:        $regfile = "m8def.dat"
+00000012:   9518        RETI                     Interrupt return
+00000013:   E58F        LDI       R24,0x5F       Load immediate
1:        $regfile = "m8def.dat"
+00000014:   BF8D        OUT       0x3D,R24       Out to I/O location
+00000015:   E3C8        LDI       R28,0x38       Load immediate
1:        $regfile = "m8def.dat"
+00000016:   E2E0        LDI       R30,0x20       Load immediate
+00000017:   2E4E        MOV       R4,R30         Copy register
1:        $regfile = "m8def.dat"
+00000018:   E084        LDI       R24,0x04       Load immediate
+00000019:   BF8E        OUT       0x3E,R24       Out to I/O location
1:        $regfile = "m8def.dat"
+0000001A:   E0D4        LDI       R29,0x04       Load immediate
+0000001B:   E0F4        LDI       R31,0x04       Load immediate
1:        $regfile = "m8def.dat"
+0000001C:   2E5F        MOV       R5,R31         Copy register
+0000001D:   95A8        WDR                      Watchdog reset
1:        $regfile = "m8def.dat"
+0000001E:   B784        IN        R24,0x34       In from I/O location
+0000001F:   2E08        MOV       R0,R24         Copy register
1:        $regfile = "m8def.dat"
+00000020:   7F87        ANDI      R24,0xF7       Logical AND with immediate
+00000021:   BF84        OUT       0x34,R24       Out to I/O location
1:        $regfile = "m8def.dat"
+00000022:   E188        LDI       R24,0x18       Load immediate
+00000023:   2799        CLR       R25            Clear Register
1:        $regfile = "m8def.dat"
+00000024:   BD81        OUT       0x21,R24       Out to I/O location
+00000025:   BD91        OUT       0x21,R25       Out to I/O location
1:        $regfile = "m8def.dat"
+00000026:   EFEE        LDI       R30,0xFE       Load immediate
+00000027:   E0F3        LDI       R31,0x03       Load immediate
1:        $regfile = "m8def.dat"
+00000028:   E6A0        LDI       R26,0x60       Load immediate
+00000029:   E0B0        LDI       R27,0x00       Load immediate
1:        $regfile = "m8def.dat"
+0000002A:   2788        CLR       R24            Clear Register
+0000002B:   938D        ST        X+,R24         Store indirect and postincrement
1:        $regfile = "m8def.dat"
+0000002C:   9731        SBIW      R30,0x01       Subtract immediate from word
+0000002D:   F7E9        BRNE      PC-0x02        Branch if not equal
1:        $regfile = "m8def.dat"
+0000002E:   2466        CLR       R6             Clear Register
10:       A = a + 1
+0000002F:   E6A0        LDI       R26,0x60       Load immediate
+00000030:   E0B0        LDI       R27,0x00       Load immediate
10:       A = a + 1
+00000031:   918C        LD        R24,X          Load indirect
+00000032:   5F8F        SUBI      R24,0xFF       Subtract immediate
10:       A = a + 1
+00000033:   938C        ST        X,R24          Store indirect
11:       if a > 250 then a = 0
+00000034:   91000060    LDS       R16,0x0060     Load direct from data space
11:       if a > 250 then a = 0
+00000036:   3F0A        CPI       R16,0xFA       Compare with immediate
+00000037:   F010        BRCS      PC+0x03        Branch if carry set
11:       if a > 250 then a = 0
+00000038:   F009        BREQ      PC+0x02        Branch if equal
+00000039:   C001        RJMP      PC+0x0002      Relative jump
11:       if a > 250 then a = 0
+0000003A:   C003        RJMP      PC+0x0004      Relative jump
+0000003B:   E080        LDI       R24,0x00       Load immediate
11:       if a > 250 then a = 0
+0000003C:   93800060    STS       0x0060,R24     Store direct to data space
12:       B = B + 1
+0000003E:   E0A8        LDI       R26,0x08       Load immediate
+0000003F:   E0B0        LDI       R27,0x00       Load immediate
12:       B = B + 1
+00000040:   918C        LD        R24,X          Load indirect
+00000041:   5F8F        SUBI      R24,0xFF       Subtract immediate
12:       B = B + 1
+00000042:   938C        ST        X,R24          Store indirect
13:       if B > 250 then B = 0
+00000043:   2D08        MOV       R16,R8         Copy register
+00000044:   EF4A        LDI       R20,0xFA       Load immediate
13:       if B > 250 then B = 0
+00000045:   1704        CP        R16,R20        Compare
+00000046:   F010        BRCS      PC+0x03        Branch if carry set
13:       if B > 250 then B = 0
+00000047:   F009        BREQ      PC+0x02        Branch if equal
+00000048:   C001        RJMP      PC+0x0002      Relative jump
13:       if B > 250 then B = 0
+00000049:   C002        RJMP      PC+0x0003      Relative jump
+0000004A:   E080        LDI       R24,0x00       Load immediate
13:       if B > 250 then B = 0
+0000004B:   2E88        MOV       R8,R24         Copy register
16:       End
+0000004C:   94F8        CLI                      Global Interrupt Disable
+0000004D:   CFFF        RJMP      PC-0x0000      Relative jump
16:       End
+0000004E:   9731        SBIW      R30,0x01       Subtract immediate from word
+0000004F:   F7F1        BRNE      PC-0x01        Branch if not equal
16:       End
+00000050:   9508        RET                      Subroutine return
+00000051:   9468        SET                      Set T in SREG
16:       End
+00000052:   F862        BLD       R6,2           Bit load from T to register
+00000053:   9508        RET                      Subroutine return
16:       End
+00000054:   94E8        CLT                      Clear T in SREG
+00000055:   F862        BLD       R6,2           Bit load from T to register
16:       End
+00000056:   9508        RET                      Subroutine return

Отредактировано sva-don (2013-03-12 09:55:48)

0

30

radan написал(а):

Нужно быстро очистить массив.

А если удалить переменную масива и создать его по новой?

ERASE/DIM

0


Вы здесь » Программирование ATMEL в BASCOM. » Вопросы - ответы » Быстро очистить массив