Главная » Bascom-8051, Basic, Железо » Вычисления и преобразования чисел BASCOM-8051

0

Bascom позволяет производить арифметические вычисления (сложение, вычитание,  умножение и деле- ние) над целыми числами (одно-, двух и четырехбайтными) и числами в формате с плавающей точкой. В следую- щей таблице показано расположение байтов переменных в памяти.

Тип

переменной

Расположение в памяти

Первый байт

(Adr*)

Второй байт

(Adr+1)

Третий байт

(Adr+2)

Четвертый байт

(Adr+3)

Однобайтовая пе-

ременная (Byte)

Байт

-

-

-

Двухбайтовая

(Word, Integer)

Младший байт

Старший байт

-

-

Четырехбайтовая

(Long)

1-й байт

(младший)

2-й байт

3-байт

4-й байт

(старший)

В формате с пла-

вающей точкой

(Single)_

1-й байт

(младший)

2-й байт

3-байт

(старший)

Байт

порядка. Вычисляется как 127+p, где p- порядок из вы- ражния:

2^p + Мантисса

Знак

Нормализованная мантасса, принимающая значения от 1 до 2,

старший бит мантиссы отбрасывается (только подразумевает-

ся наличие всегда равного 1).

Примеры кода       00 00 80 3F = 1 чисел в порядке,   00 00 00 40 = 2 расположения в     00 00 80 40 = 4 памяти             00 00 00 41 = 8

00 00 80 41 = 16

00 00 00 42 = 32

00 00 80 42 = 64

00 00 00 43 = 128

00 00 20 C1 = -10

00 00 20 C0 = -2.5

0 -

плюс 1 – ми-

нус

*  Adr – адрес переменной определенный при компиляции

Bascom с целыми двухбайтными числами может выполнять знаковые (с переменными  типа Integer и Long) и беззнаковые (с переменными типа Byte и Word) арифметические операции. Арифметические операции с четырехбайтными числами всегда производятся с учетом знака. При целочисленных вычислениях длина результа- та, не может превышать длины исходных числовых переменных. Даже при умножении 8-разрядных чисел резуль- тат будет тоже 8-разрядным. Аналогично для 16-разрядных и 32-разрядных чисел. Смешанные произведения дают результат,  равный по длине, более длинной переменной. Главная неприятность этой особенности  компилятора заключается в том, что при переполнении (возможном при сложении и особенно умножении) теряются старшие разряды. Эта ошибка не показывается компилятором потому, что считается ошибкой программиста. Чтобы этого не происходило, сложение и умножение при наличии вероятности переполнения нужно выполнять с использова- нием переменных двойной  длины, а это значительно увеличивает время операции, или применять быструю ас- семблерную программу с собственной программой сложения и умножения. Ниже приведена одна такая програм- ма.

Компилятор может производить много вариантов преобразования чисел в явном (с помощью специаль- ных операторов) или в неявном виде (при выполнении других операции). Преобразование в неявном виде проис- ходит при перезаписи данных или при вычислении значения операндов разного типа. Причем, если преобразова- ние  производится  при  считывании  исходных  значений  (до  выполнения  назначенной  операции),  вероятность ошибки невелика, т.к. компилятор выбирает подпрограмму обработки, в зависимости от типа исходных перемен- ных. Если запись результата назначена в регистр, отличающийся по типу, от переменных, применяемых при вы- числениях, то ошибка неизбежна, т.к. компилятор использует имя переменной-приемника уже механически. При наличии ошибки несоответствия длины результата и размера переменной, куда помещается результат, последняя может быть заполнена не полностью или, еще хуже, перекрыта по длине. Эти ошибки также не выявляются и не показываются компилятором. Ошибки подобного рода исключены, при выполнении специальных операций пре- образования, когда компилятор проверяет размерность переменной – приемника данных;

Ниже приведена программа, в которой имеются примеры вычисления и преобразования чисел, выполняе-

мые компилятором Bascom.

‘—————————————————-

‘  Преобразование числовых переменных и вычисления

‘—————————————————-

$large

Dim Cnt As Const 5              ‘число 5

Dim Bt As Bit                   ‘определим по паре переменных всех типов

Dim Byt As Byte , Byt1 As Byte Dim Wrd As Word , Wrd1 As Word

Dim Intg As Integer , Intg1 As Integer Dim Lng As Long , Lng1 As Long

Dim Sng As Single , Sng1 As Single

‘—————————————————- Set Bt                          ‘установить бит

‘—————————————————- ‘преобразование переменных

Byt = Bt                        ‘значение бита помещается в младший разряд

Byt = Cnt                       ‘записать число (константу)

Wrd = Byt                       ‘в младший байт данные, в старший байт 00

Intg = Wrd                      ‘переместить данные без изменений

Intg = Not Intg                 ‘инвертировать

Wrd = Intg                      ‘обратно без изменений

Sng = Wrd : Print Sng           ‘преобразовать в плавающую Sng = 65550.0

Sng = Intg : Print Sng          ‘преобразовать в плавающую Sng = -6.0 ‘—————————————————-

‘целочисленные вычисления

Intg = Intg * 5 : Print Intg    ‘результат Intg = -30

Intg = Intg / 5 : Print Intg    ‘рузультат Intg = -6

Intg1 = 1000

Intg = Intg1 / Intg : Print Intg’результат Intg = -166

Intg = Intg * -1                ‘смена знака. Это медленный вариант

Intg = Not Intg : Intg = Intg + 1 ‘аналогично, но работает намного быстрее

Intg = Not Intg : Incr Intg     ‘тоже работает быстро

Lng = Intg             ‘чтобы получить 32-разр. результат умножения, Lng = Lng * Intg        ‘хотя бы один из операндов должен быть 32-разр. Lng = 1000000 : Lng = Not Lng   ‘инверсия для смены знака

Incr Lng                        ‘-1000001 + 1 = -1000000

Print Lng                       ‘результат Lng = -1000000

Lng = Lng / 1000                ‘деление на константу

Print Lng                       ‘результат Lng = -1000

Wrd = Lng / 1000    ‘так неправильно, хотя компилятор ошибку не покажет

Lng = Lng / 1000 : Wrd = Lng    ‘а это правильно

Intg1 = -10

Lng = Lng / Intg1               ‘деление на переменную другой размерности

Print Lng                       ‘результат Lng = 100

‘—————————————————-

‘вычисление с плав. точкой

Sng = Sng * Lng                 ‘умножение целого числа на плавающее

Print Sng                       ‘результата Sng = -600.0

Sng1 = 0.15 : Sng = Sng * Sng1  ‘умножение плавающих чисел

Print Sng                       ‘результата Sng = -90.0

Sng = Sng / -10                 ‘деление на константу

Print Sng                       ‘результата Sng = 9.0

$asm

Xrl {Sng+3} , #&h80    ‘мгновенная смена знака числа с плав. точкой

Anl {Sng+3} , #&h7f    ‘или установка положительной полярности

Prl {Sng+3} , #&h80    ‘или установка отрицательной полярности

$end asm

‘—————————————————- ‘демонстрация неправильного умножения

Byt = 10 : Byt1 = 15 : Wrd = &H1234       ‘назначим числа

Wrd = Byt * Byt1     ‘произведение сразу запишем в двухбайтное число

Printhex Wrd         ‘результат Wrd = 1296h – только в младших разрядах

Byt = Byt * Byt1                ‘проделываем это же иначе, а затем

Wrd = Byt                       ‘переписываем с очисткой старших разрядов

Byt1 = Wrd                      ‘обратно берутся только младшие разряды и Print Byt ; " " ; Byt1 ; " " ; Wrd ‘теперь результат везде одинаков = 150 ‘—————————————————-

‘ определим время исполнения арифметических операций

Byt = 50 : Byt1 = 10            ‘назначим числа

Byt = Byt + Byt1                ‘сложение – 11 тактов

Byt = 50 : Byt1 = 10            ‘ числа

Byt = Byt – Byt1                ‘вычитание – 12 тактов

Byt = 20 : Byt1 = 10            ‘ числа

Byt = Byt * Byt1                ‘умножние – 10 тактов

Byt = 50 : Byt1 = 10            ‘ числа

Byt = Byt / Byt1                ‘деление – 10 тактов

‘—————————————————- Wrd = 500 : Wrd1 = 100          ‘ числа

Wrd = Wrd + Wrd1                ‘сложение – 20 тактов

Wrd = 500 : Wrd1 = 100          ‘ числа

Wrd = Wrd – Wrd1                ‘вычитание – 21 такт

Wrd = 200 : Wrd1 = 100          ‘ числа

Wrd = Wrd * Wrd1                ‘умножние – 63 такта

Wrd = 500 : Wrd1 = 100          ‘ числа

Wrd = Wrd / Wrd1                ‘деление – 560 тактов ‘—————————————————- Intg = 500 : Intg1 = -100       ‘ числа

Intg = Intg + Intg1             ‘сложение – 20 тактов

Intg = 500 : Intg1 = -100       ‘ числа

Intg = Intg – Intg1             ‘вычитание – 21 тактов

Intg = 200 : Intg1 = -100       ‘ числа

Intg = Intg * Intg1             ‘умножние – 95 тактов

Intg = 500 : Intg1 = -100       ‘ числа

Intg = Intg / Intg1             ‘деление – 620 тактов ‘—————————————————- Lng = -5000 : Lng1 = 1000       ‘ числа

Lng = Lng + Lng1                ‘сложение – 74 такта

Lng = -5000 : Lng1 = 1000       ‘ числа

Lng = Lng – Lng1                ‘вычитание – 74 такта

Lng = -2000 : Lng1 = 1000       ‘ числа

Lng = Lng * Lng1                ‘умножние – 2500 тактов

Lng = -5000 : Lng1 = 1000       ‘ числа

Lng = Lng / Lng1                ‘деление – 3200 тактов

‘—————————————————- Sng = 50 : Sng1 = 10            ‘ числа

Sng = Sng + Sng1                ‘сложение – 240 тактов

Sng = 50 : Sng1 = 10            ‘ числа

Sng = Sng – Sng1                ‘вычитание – 290 тактов

Sng = 20 : Sng1 = 10            ‘ числа

Sng = Sng * Sng1                ‘умножение – 2000 тактов

Sng = 50 : Sng1 = 10            ‘ числа

Sng = Sng / Sng1                ‘деление – 2300 тактов ‘—————————————————- ‘определим время исполнения преобразований

Byt = 100 : Sng = Byt           ‘байт в плавающую – 490 тактов

‘обратно преобразования не производится

Wrd = 10000 : Sng = Wrd         ‘слово в плавающую -370 тактов

Wrd = Sng                       ‘обратно -340 тактов

Intg = -1000 : Sng = Intg       ‘знаковое слово в плав. – 470 тактов

Intg = Sng                      ‘обратно – 420 тактов

Lng = 1000000 : Sng = Lng       ‘двойное слово в плав. – 280 тактов

Lng = Sng                       ‘обратно – 250 тактов ‘—————————————————- End

В демонстрационной программе имеются ответы почти на все вопросы применения операций преобразова-

ния и использования в вычислениях числовых переменных. Нужно заметить, что измеренные значения произво-

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

числа, особенно в операциях с плавающей точкой, и еще в большей степени при операции деления. Разница в ре-

зультате при использовании знаков деления “/” и “\” не замечена.

Ниже дается пример быстрой ассемблерной программы беззнакового умножения  16-разрядных чисел,

дающей 32-разрядный результат.

;———————————————-

;УМНОЖЕНИЕ ДВУХБАЙТНОГО ЧИСЛА НА ДВУХБАЙТНОЕ ЧИСЛО.

;ВРЕМЯ ИСПОЛНЕНИЯ 52 ТАКТА.

;ИСХОДНЫЕ ЧИСЛА: В R3-СТ.,R2-МЛ. И R1-СТ.,R0-МЛ. РЕЗУЛЬТАТ В R7-СТ.,R6,R5,R4

;———-

MUL2B:  ;УМНОЖЕНИЕ МЛАДШИХ ЦИФР ПЕРВОГО И ВТОРОГО ЧИСЛА

MOV     A,R2

MOV     B,R0

MUL     AB MOV     R4,A MOV     R5,B

;УМНОЖЕНИЕ МЛАДШЕЙ ЦИФРЫ ПЕРВОГО ЧИСЛА НА СТАРШУЮ ВТОРОГО ЧИСЛА

MOV     A,R2

MOV     B,R1

MUL     AB

;СЛОЖИТЬ С ПРЕДЫДУЩИМ РЕЗУЛЬТАТОМ

ADD     A,R5

MOV     R5,A CLR     A ADDC    A,B MOV     R6,A

;УМНОЖЕНИЕ МЛАДШЕЙ ЦИФРЫ ВТОРОГО ЧИСЛА НА СТАРШУЮ ПЕРВОГО ЧИСЛА

MOV     A,R3

MOV     B,R0

MUL     AB

;СЛОЖИТЬ С ПРЕДЫДУЩИМ РЕЗУЛЬТАТОМ

ADD     A,R5

MOV     R5,A

MOV     A,R6

ADDC    A,B

MOV     R6,A

CLR     A

RLC     A

MOV     R7,A

;УМНОЖЕНИЕ СТАРШИХ ЦИФР ПЕРВОГО И ВТОРОГО ЧИСЛА

MOV     A,R3

MOV     B,R1

MUL     AB

;СЛОЖИТЬ С ПРЕДЫДУЩИМ РЕЗУЛЬТАТОМ

ADD     A,R6

MOV     R6,A

MOV     A,R7

ADDC    A,B

MOV     R7,A

;—————————————————-

Bascom позволяет производить очень сложные вычисления, благодаря краткой форме записи производи-

мых действий. Компилятор при этом создает очень компактный код, содержащий только установку исходных зна- чений и вызов библиотечных подпрограмм. При реализации сложных формул необходимо раскладывать ее на ряд последовательно   выполняемых операций,   каждая из которых  должна содержать только одно действие. Чтобы уменьшить число переменных, используемых при вычислениях, необходимо анализировать порядок их использо- вания, занимая для хранения промежуточных результатов регистры с уже ненужными данными. Ниже, в качестве примера,  приведена простая подпрограмма для вычисления квадратного корня. У данной программы есть  одна неприятность – неопределенность результата при нулевом значении аргумента. Чтобы избавится от этого недос- татка, к исходному числу добавляется любое незначительное число.

‘—————————————————- ‘ тестирование программы вычисления квадратного корня

Dim X As Single , Y As Single , Z As Single       ‘временные значения

Do

Input "x=" , X

X = X + 0.00001  ‘чтобы никогда не было нулевого значения, которое

‘вызывает переполнение при вычислении квадратного корня

Gosub Sqr        ‘теперь вычислим квадратный корень (время вычисления 50 мс) Print Y          ‘посмотрим результат

Loop

‘—————————–

‘подпрограмма вычисления квадратного корня по формуле Ньютона

‘вычисление производится методом последовательных приближений: ‘          Yi+1 = (X / Yi + Yi) * .5

‘начальное (исходное) значение вычисляется по формуле: ‘              Y0 = X / 200 + 2

Sqr:

‘вычислим начальное значение, с которого начнем иттерацию

Y = X * 0.005 : Y = Y + 2

Do

‘вычислим очередное значение корня Y = (X / Y + Y) * .5

Z = Y : Y = X / Y : Y = Y + Z : Y = Y * 0.5

‘проверим IF ABS(Y1 – Y) > Y / 1000 GOTO srq_1

‘в Bascom функция ABS не работает с числами в формате с плавающей точкой

Z = Z – Y : Z = Z / Y    ‘вычисляем отношение между посл. и предпосл. значение

$asm

Anl {z + 3} , #&H7f     ; делаем абсолютное значение стиранием знака

$end Asm

Loop Until Z < 0.001          ‘если необходимая точность достигнута (0.1 %) Return                          ‘выходим

‘—————————————————-

Далее приведены еще несколько подпрограмм для вычисления функций методом разложения в степенной ряд. В этих программах для сокращения размера кода применена  упаковка повторяющихся операций в подпро- граммы, что значительно сокращает размер кода (2 – 3 раза).

‘————————————————————————– ‘вычисление десятичного логарифма. Log(x) функция в Ua от аргумента Ua

‘————————————————————————–

Log:

‘выделим порядок (двоичный исходного числа), а остаток сделаем

‘числом в диапазоне от 1 до 2

$asm

Mov R0 , #{ua + 2}

Mov A , @R0

Mov C , Acc.7

Clr Acc.7

Mov @R0, A Inc R0

Mov A , @r0

Rlc A

Mov {tmpb} , A Mov @R0 , #&H40

$end Asm

‘Числа для справки:

‘ln(2)= 0,69314718, 1/ln(2)=1.442695, ln(10)=2.3025851, 1/ln(10)=0.4342945

Gosub Ln                              ‘вычислим натуральный логарифм остатка

Ua = Ua * 1.442695                    ‘преобразуем в двоичный логарифм остатка

Ub = Tmpb : Ub = Ub – 128 : Ua = Ua + Ub ‘объединим порядок и логарифм остатка

‘и получим двоичный логарифм числа

Ua = Ua * 0.30103001                  ‘преобразуем в десятичный логарифм

Return

‘————————————————————————– ‘вычисление натурального логарифма. Ln(x) функция в Ua от аргумента Ua ‘очень хорошая точность только от x = 1 до x = 3 (около 0.003 %)

‘при x = 5 погрешность около 0.02 %, а при x = 10 – 0.7 % ‘

‘               3   5   7   9   11   13     n

‘              p   p   p   p   p    p      p             x-1

‘ ln(x)=2*[p + – + – + – + – + — + — …+-]  где  p = —– ‘              3   5   7   9   11   13     n             x+1

‘————————————————————————– Ln:

Ub = Ua – 1 : Ua = Ua + 1

Ua = Ub / Ua

Ub = Ua * Ua : Uc = Ub * Ua : Ud = Uc * 0.3333333 : Gosub Add_aad Gosub Mul_cbc : Ud = Uc * 0.2 : Gosub Add_aad

Gosub Mul_cbc : Ud = Uc * 0.14285714 : Gosub Add_aad

Gosub Mul_cbc : Ud = Uc * 0.1111111111 : Gosub Add_aad Gosub Mul_cbc : Ud = Uc * 0.09090909 : Gosub Add_aad

Gosub Mul_cbc : Ud = Uc * 0.07692308 : Gosub Add_aad  ‘точность 0.003 % ‘    Gosub Mul_cbc : Ud = Uc * 0.06666667 : Gosub Add_aad

‘    Gosub Mul_cbc : Ud = Uc * 0.05882353 : Gosub Add_aad

‘    Gosub Mul_cbc : Ud = Uc * 0.05263158 : Gosub Add_aad Ua = Ua + Ua : Return

‘———————

‘для сокращения размера кода повторяющиеся программы выделим

Mul_cbc:

Uc = Ub * Uc : Return ‘——————— Add_aad:

Ua = Ua + Ud : Return ‘———————

‘————————————————————————– ‘синусная функция в Ua от аргумента Ua в радианах

‘хорошая точность только до 90 град (около 0.0002 %) ‘при 180 град погрешность достигает 4 %!!!

Sin:

Ub = Ua : Ua = Ua * Ua Uc = Ua

Ua = Ua * 0.013888889                   ‘ 1/72

Gosub Sub_aa1

Gosub Mul_aac

Ua = Ua * 0.0238095243                  ‘1/42

Gosub Add_aa1

Gosub Mul_aac

Ua = Ua * .05                           ‘1/20

Gosub Sub_aa1

Gosub Mul_aac

Ua = Ua * 0.16666667                    ‘1/6

Gosub Add_aa1

Gosub Mul_aab

Return

‘——————— Add_aa1:

Ua = Ua + 1

Return

‘———————

Sub_aa1:

Ua = Ua –  1

Return

‘——————— Mul_aac:

Ua = Ua * Uc Return

‘———————

Mul_aab:

Ua = Ua * Ub Return

‘————————————————————————–

‘косинусная функция в Ua от аргумента Ua в радианах

‘хорошая точность только до 90 град (около 0.003 % от максимального значения) ‘при 180 град погрешность достигает 3 %!!!

Cos:

Ua = Ua * Ua                            ‘angle squared

Ub = Ua                                 ‘save Ua = Ua * 0.017857144                   ‘1/56

Gosub Sub_aa1

Gosub Mul_aab

Ua = Ua * 0.033333333                   ‘1/30

Gosub Add_aa1

Gosub Mul_aab

Ua = Ua * 0.083333333                   ‘1/12

Gosub Sub_aa1

Gosub Mul_aab

Ua = Ua * 0.5                           ‘1/2

Gosub Add_aa1

Return

‘————————————————————————– ‘показательная функция e^x в Ua от аргумента Ua в радианах

‘хорошая точность только до x = 3 (около 0.002 %) ‘точность при x = 4 (около 0.07 %), а при x = 10 – 4 % Exp:

Ub = Ua + 1                                               ‘1+x/1! Gosub Mul_cac : Ud = Uc * 0.5 : Gosub Add_bbd             ‘+x^2/2! Gosub Mul_cac : Ud = Uc * 0.16666667 : Gosub Add_bbd      ‘+x^3/3! Gosub Mul_cac : Ud = Uc * 0.041666667 : Gosub Add_bbd     ‘+x^4/4! Gosub Mul_cac : Ud = Uc * 0.008333333 : Gosub Add_bbd     ‘+x^5/5! Gosub Mul_cac : Ud = Uc * 0.0013888889 : Gosub Add_bbd    ‘+x^6/6! Gosub Mul_cac : Ud = Uc * 0.0001984127 : Gosub Add_bbd    ‘+x^7/7! Gosub Mul_cac : Ud = Uc * 0.000024801587 : Gosub Add_bbd  ‘+x^8/8! Gosub Mul_cac : Ud = Uc * 0.000002755732 : Gosub Add_bbd  ‘+x^9/9! Gosub Mul_cac : Ud = Uc * 0.0000002755732 : Gosub Add_bbd ‘+x^10/10!

Return

‘———————

Add_bbd:

Ub = Ub + Ud : Return ‘——————— Mul_cac:

Uc = Uc * Ua : Return

‘——————— Add_cad:

Ua = Ua + Ud : Return

‘————————————————————————–

Возможность применения тех или иных вычислительных программ частот обусловлена производительно- стью микроконтроллера. Далее приведена программа цифрового фильтра  нижних  частот третьего порядка. Для его реализации с указанной частотной характеристикой требуется очень высокая производительность микрокон- троллера – в десять раз выше  стандартной  (эквивалентно более 120 МГц). Для этого могут быть использованы только улучшенные модели W77E58, DS89C420). При использовании микроконтроллера с ядром AVR эта и все приведенные  выше  вычислительные  программы  работают  быстрее  в  среднем  в  50  раз  (компилированные BasAVR).

‘————————————————————————– ‘ фильтр с частотой среза около 5-10 Гц при частоте выборок 500 Гц

‘ (частоте вызова данной программы). Коэффициент передачи фильтра: ‘               1                   1

‘ К =  ———————– * ——— ‘      0.006*p^2 + 0.111*p + 1   0.1*p + 1

‘а это коэффициенты цифрового фильтра

Const _a = 0.013869625

Const _b = -0.83217753

Const _c = 1.8183079

Const _d = 0.09090909

Const _e = 0.9090909

‘———————

Dim Ux As Single                  ‘входное значение

Dim Uy As Single                  ‘выходное значение первого звена

Dim Uy1 As Single                 ‘предыдущее выходное значение первого звена

Dim Uy2 As Single                 ‘предпредыдущее выходное значение первого звена

Dim Uz As Single                  ‘выходное значение второго звена

Dim Uz1 As Single                 ‘предыдущее выходное значение второго звена

‘————————

‘   программа цифрового фильтра третьего порядка содержащего два звена

‘   2-го и 1-го порядка:

‘  Uy = Ux * a + Uy2 * b + Uy1 * c – формула звена второго порядка

‘  Uz = Uy * d + Uz1 * e – формула фильтра звена первого порядка

‘—–

Filtr_3p:

Uy = Ux * _a : Uz = Uy2 * _b : Uy = Uy + Uz  ‘программа фильтра второго порядка

Uz = Uy1 * _c : Uy = Uy + Uz Uy2 = Uy1 : Uy1 = Uy

‘—–

Uz = Uy * _d : Uy = Uz1 * _e : Uz = Uy + Uz  ‘программа фильтра первого порядка

Uz1 = Uz : Return

‘——————————————

Bascom версий 2.хх расширил диапазон возможных действий с битовыми переменными.  Теперь стала возможным операция с индексированными битами. Причем в качестве индекса может выступать другая перемен- ная, и конечно только байтовая. Например:

Dim X As Byte , Y As Byte

X.3 = Y.2 : P2.1 = Y.4 ‘передача значений между битами байтовых переменных

For X = 0 To 7             ‘индексирование бита

Set P3.X

Next

If P2.X=1 Then             ‘проверка индексированного бита

P2.X = 0

End If

Источник: М.Л.Кулиш, СПРАВОЧНИК ПО ПРОГРАММИРОВАНИЮ BASCOM-8051, Краснодар 2001

По теме:

  • Комментарии