Ім'я файлу: Арх_комп_КСД12_Гайдук_КР.pdf
Розширення: pdf
Розмір: 997кб.
Дата: 13.02.2022
скачати
Пов'язані файли:
пояснительная_записка.doc
Розширення: pdf
Розмір: 997кб.
Дата: 13.02.2022
скачати
Пов'язані файли:
пояснительная_записка.doc
{ p = i; break;
} p = 15-p;
// Машинный порядок. unsigned char mash_por = p + 127;
// Знак. int sign; if (x >= 0) sign = 0; else sign = 1;
// Мантисса. Первый разряд пропускаем. bool mant[23]; for(int i=0;i<23;i++) mant[i] = dw[15-p+1+i];
// Округление последнего разряда. if (dw[15-p+24] == 1) mant[22] = 1;
// Заносим знак. out[0] = bool(sign);
// Заносим порядок. for(int i=8;i>=1;i--) out[i] = bool((mash_por >> (8-i)) & 1);
} p = 15-p;
// Машинный порядок. unsigned char mash_por = p + 127;
// Знак. int sign; if (x >= 0) sign = 0; else sign = 1;
// Мантисса. Первый разряд пропускаем. bool mant[23]; for(int i=0;i<23;i++) mant[i] = dw[15-p+1+i];
// Округление последнего разряда. if (dw[15-p+24] == 1) mant[22] = 1;
// Заносим знак. out[0] = bool(sign);
// Заносим порядок. for(int i=8;i>=1;i--) out[i] = bool((mash_por >> (8-i)) & 1);
74
// Заносим мантиссу. for(int i=0;i<23;i++) out[i+9] = mant[i];
// Результат как число. for(int i=0;i<32;i++)
{ tmp = out[i]; tmp = tmp << 31-i;
*res = *res | tmp;
}
// Печать результата. printf("HEX = %08x",*res);
} int main()
{ setlocale(0,""); printf("\n "); float x; bool out[32];
DWORD res; while(1)
{ printf("DEC = "); scanf("%f",&x); printf("\n "); format(x,out,&res); printf("\n\n ");
} printf("\n\n "); system("PAUSE"); return 0;
} Приложение 2. Программа преобразования чисел из машинного кода в десятичное представление
#include "stdafx.h"
#include "iostream"
#include "math.h"
#include "windows.h"
// Печать в двоичном представлении. void print_as_bin (int x, int d)
{ if (d == 0) return; print_as_bin(x >> 1,--d); printf("%d",x & 1);
}
// Преобразование целого числа в массив битов. void int_to_bin (int x, int d, bool* mas)
{ if (d == 0) return;
75 mas[d-1] = bool(x & 1); int_to_bin(x >> 1,--d,mas);
}
// max = 65535 min = 0 void int_to_bin16 (int x, bool* mas)
{ int_to_bin(x,16,mas);
}
// Преобразование дробной части числа в массив битов. void fract_to_bin (float x, int d, bool* mas, int cap)
{ if (d == 0) return; mas[cap-d] = bool(int(x*2)); fract_to_bin(x*2-int(x*2),--d,mas,cap);
}
// 16+23. Разряды дробной части вычисляем с запасом. void fract_to_bin39 (float x, bool* mas)
{ fract_to_bin(x,39,mas,39);
}
// Представление числа по стандарту IEEE-754. void format (float x, bool* out, DWORD* res)
{ bool cel[16], drobn[39]; bool dw[55];
DWORD tmp;
*res = 0;
// Если ноль, то результат выдаем сразу. if (x == 0)
{ printf("HEX = %08x",0); for(int i=0;i<32;i++) out[i] = 0; return;
}
// Получение целой и дробной части модуля. int c = int(abs(x)); float d = abs(x)-int(abs(x));
// Переводим их в двоичную систему. int_to_bin16(c,cel); fract_to_bin39(d,drobn);
// Загоняем в рабочий массив. for(int i=0;i<16;i++) dw[i] = cel[i]; for(int i=0;i<39;i++) dw[i+16] = drobn[i];
// Определяем порядок. int p = 0; for(int i=0;i<32;i++) if (dw[i] == 1)
{ p = i; break;
} p = 15-p;
76
// Машинный порядок. unsigned char mash_por = p + 127;
// Знак. int sign; if (x >= 0) sign = 0; else sign = 1;
// Мантисса. Первый разряд пропускаем. bool mant[23]; for(int i=0;i<23;i++) mant[i] = dw[15-p+1+i];
// Округление последнего разряда. if (dw[15-p+24] == 1) mant[22] = 1;
// Заносим знак. out[0] = bool(sign);
// Заносим порядок. for(int i=8;i>=1;i--) out[i] = bool((mash_por >> (8-i)) & 1);
// Заносим мантиссу. for(int i=0;i<23;i++) out[i+9] = mant[i];
// Результат как число. for(int i=0;i<32;i++)
{ tmp = out[i]; tmp = tmp << 31-i;
*res = *res | tmp;
}
// Печать результата. printf("HEX = %08x",*res);
}
// Машинное представление в вещественное число. float repack (unsigned int x)
{ int sign; unsigned int tmp, mant; // 4 bytes;
// Определяем знак. sign = (x >> 31) & 1;
// Определяем порядок. int pzn; tmp = x; tmp = tmp << 1; // Порядок – последние 8 бит. tmp &= 0xFF000000; tmp = tmp >> 24; // Вычленили порядок. pzn = (int)tmp; pzn -= 127;
// Выделяем мантиссу, не забывая про первую единицу. tmp = x; tmp &= 0x007FFFFF; tmp |= 0x00800000; mant = tmp;
77
// Выделяем целую и дроб. части в двоичном представлении. unsigned int cel, drob; cel = mant >> (23 - pzn); // Целая часть. drob = mant << 9 + pzn; // Дроб. часть (по правому краю.
// Считаем дроб. часть. float drch = 0; float pw = 1.0/2; for(int i=0;i<32;i++)
{ drch += (((drob << i) & 0x80000000) >> 31) * pw; pw /= 2;
}
// Устанавливаем знак. float res; res = cel + drch; if (sign) res *= -1; return res;
} int main()
{ setlocale(0,""); printf("\n "); float x; unsigned long h; while(1)
{ printf("HEX = "); scanf("%8x",&h); printf("\n "); x = repack(h); printf("DEC = %f",x); printf("\n\n ");
} printf("\n\n "); system("PAUSE"); return 0;
} Приложение 3. Подпрограммы пересылки данных
;*******************************************************************************
;
; Макросы и подпрограммы пересылки данных.
;
;*******************************************************************************
;*******************************************************************************
; Настройка верхушки стека.
;*******************************************************************************
.macro InitStack ldi temp, High(RAMEND) out sph, temp ldi temp, Low(RAMEND) out spl, temp
.endm
78
;*******************************************************************************
; PUSH A
;*******************************************************************************
.macro PushA push pA push mAH push mAM push mAL
.endm
;*******************************************************************************
; POP A
;*******************************************************************************
.macro PopA pop mAL pop mAM pop mAH pop pA
.endm
;*******************************************************************************
; PUSH B
;*******************************************************************************
.macro PushB push pB push mBH push mBM push mBL
.endm
;*******************************************************************************
; POP B
;*******************************************************************************
.macro PopB pop mBL pop mBM pop mBH pop pB
.endm
;*******************************************************************************
; PUSH C
;*******************************************************************************
.macro PushC push _pC push mCH push mCM push mCL
.endm
;*******************************************************************************
; POP C
;*******************************************************************************
.macro PopC pop mCL pop mCM pop mCH pop _pC
.endm
;*******************************************************************************
; Сохранение 4-хбайтного регистра A в буфер.
;*******************************************************************************
AToBuf:
79 sts buff, pA sts buff+1, mAH sts buff+2, mAM sts buff+3, mAL ret
;*******************************************************************************
; Восстановление А из буфера.
;*******************************************************************************
BufToA: lds pA, buff lds mAH, buff+1 lds mAM, buff+2 lds mAL, buff+3 ret
;*******************************************************************************
; Копирование из буфера в В.
;*******************************************************************************
BufToB: lds pB, buff lds mBH, buff+1 lds mBM, buff+2 lds mBL, buff+3 ret
;*******************************************************************************
; CLR для регистра A.
;*******************************************************************************
ClrA: clr pA clr mAH clr mAM clr mAL ret
;*******************************************************************************
; CLR для регистра B.
;*******************************************************************************
ClrB: clr pB clr mBH clr mBM clr mBL ret
;*******************************************************************************
; CLR для регистра C.
;*******************************************************************************
ClrC: clr _pC clr mCH clr mCM clr mCL ret
;*******************************************************************************
; MOV A -> B
;*******************************************************************************
MovAToB: mov pB, pA mov mBH, mAH mov mBM, mAM mov mBL, mAL
80 ret
;*******************************************************************************
; MOV A -> C
;*******************************************************************************
MovAToC: mov _pC, pA mov mCH, mAH mov mCM, mAM mov mCL, mAL ret
;*******************************************************************************
; MOV C -> A
;*******************************************************************************
MovCToA: mov pA, _pC mov mAH, mCH mov mAM, mCM mov mAL, mCL ret
;*******************************************************************************
; MOV C -> B
;*******************************************************************************
MovCToB: mov pB, _pC mov mBH, mCH mov mBM, mCM mov mBL, mCL ret
;*******************************************************************************
; MOV B -> A
;*******************************************************************************
MovBToA: mov pA, pB mov mAH, mBH mov mAM, mBM mov mAL, mBL ret
;*******************************************************************************
; MOV B -> C
;*******************************************************************************
MovBToC: mov _pC, pB mov mCH, mBH mov mCM, mBM mov mCL, mBL ret
;*******************************************************************************
; Load Time To B
;*******************************************************************************
LoadTimeToB: lds pB, time lds mBH, time+1 lds mBM, time+2 lds mBL, time+3 ret
;*******************************************************************************
; Load YYYY To N
81
;*******************************************************************************
LoadYYYYToN: lds temp, year sts n_jd, temp lds temp, year+1 sts n_jd+1, temp lds temp, year+2 sts n_jd+2, temp lds temp, year+3 sts n_jd+3, temp ret
;*******************************************************************************
; Load A To M
;*******************************************************************************
LoadAToM: sts m_jd, pA sts m_jd+1, mAH sts m_jd+2, mAM sts m_jd+3, mAL ret
;*******************************************************************************
; Load M To A
;*******************************************************************************
LoadMToA: lds pA, m_jd lds mAH, m_jd+1 lds mAM, m_jd+2 lds mAL, m_jd+3 ret
;*******************************************************************************
; Load A To N
;*******************************************************************************
LoadAToN: sts n_jd, pA sts n_jd+1, mAH sts n_jd+2, mAM sts n_jd+3, mAL ret
;*******************************************************************************
; Load N To A
;*******************************************************************************
LoadNToA: lds pA, n_jd lds mAH, n_jd+1 lds mAM, n_jd+2 lds mAL, n_jd+3 ret
;*******************************************************************************
; Load A To P
;*******************************************************************************
LoadAToP: sts p_jd, pA sts p_jd+1, mAH sts p_jd+2, mAM sts p_jd+3, mAL ret
82
;*******************************************************************************
; Load P To A
;*******************************************************************************
LoadPToA: lds pA, p_jd lds mAH, p_jd+1 lds mAM, p_jd+2 lds mAL, p_jd+3 ret
;*******************************************************************************
; Load A To JD
;*******************************************************************************
LoadAToJD: sts jdate, pA sts jdate+1, mAH sts jdate+2, mAM sts jdate+3, mAL ret
;*******************************************************************************
; Load JD To A
;*******************************************************************************
LoadJDToA: lds pA, jdate lds mAH, jdate+1 lds mAM, jdate+2 lds mAL, jdate+3 ret
;*******************************************************************************
; Load A To T
;*******************************************************************************
LoadAToT: sts jcent, pA sts jcent+1, mAH sts jcent+2, mAM sts jcent+3, mAL ret
;*******************************************************************************
; Load T To A
;*******************************************************************************
LoadTToA: lds pA, jcent lds mAH, jcent+1 lds mAM, jcent+2 lds mAL, jcent+3 ret
;*******************************************************************************
; Star0 <- A
;*******************************************************************************
AToStar0: sts star0, pA sts star0+1, mAH sts star0+2, mAM sts star0+3, mAL ret
83
;*******************************************************************************
; Star0 -> A
;*******************************************************************************
Star0ToA: lds pA, star0 lds mAH, star0+1 lds mAM, star0+2 lds mAL, star0+3 ret
;*******************************************************************************
; Load A To TimeP
;*******************************************************************************
LoadAToTimeP: sts ptime, pA sts ptime+1, mAH sts ptime+2, mAM sts ptime+3, mAL ret
;*******************************************************************************
; Load TimeP To A
;*******************************************************************************
LoadTimePToA: lds pA, ptime lds mAH, ptime+1 lds mAM, ptime+2 lds mAL, ptime+3 ret
;*******************************************************************************
; Load A To Longitude
;*******************************************************************************
LoadAToLongitude: sts longt, pA sts longt+1, mAH sts longt+2, mAM sts longt+3, mAL ret
;*******************************************************************************
; Load Longitude To A
;*******************************************************************************
LoadLongToA: lds pA, longt lds mAH, longt+1 lds mAM, longt+2 lds mAL, longt+3 ret
;*******************************************************************************
; Load A To StarTime
;*******************************************************************************
LoadAToStarTime: sts tstar, pA sts tstar+1, mAH sts tstar+2, mAM sts tstar+3, mAL
84 ret
;*******************************************************************************
; Load StarTime To A
;*******************************************************************************
LoadStarTimeToA: lds pA, tstar lds mAH, tstar+1 lds mAM, tstar+2 lds mAL, tstar+3 ret
;*******************************************************************************
; Load A To Latitude
;*******************************************************************************
LoadAToLatit: sts lattd, pA sts lattd+1, mAH sts lattd+2, mAM sts lattd+3, mAL ret
;*******************************************************************************
; Load Latitude To A
;*******************************************************************************
LoadLatitToA: lds pA, lattd lds mAH, lattd+1 lds mAM, lattd+2 lds mAL, lattd+3 ret
;*******************************************************************************
; Load A To Decline
;*******************************************************************************
LoadAToDecl: sts decln, pA sts decln+1, mAH sts decln+2, mAM sts decln+3, mAL ret
;*******************************************************************************
; Load Decline To A
;*******************************************************************************
LoadDeclToA: lds pA, decln lds mAH, decln+1 lds mAM, decln+2 lds mAL, decln+3 ret
;*******************************************************************************
; Load A To RisgSun
;*******************************************************************************
LoadAToRisgSun: sts rgsun, pA sts rgsun+1, mAH
85 sts rgsun+2, mAM sts rgsun+3, mAL ret
;*******************************************************************************
; Load RisgSun To A
;*******************************************************************************
LoadRisgSunToA: lds pA, rgsun lds mAH, rgsun+1 lds mAM, rgsun+2 lds mAL, rgsun+3 ret
;*******************************************************************************
; Load A To TmAng
;*******************************************************************************
LoadAToTmAng: sts tmang, pA sts tmang+1, mAH sts tmang+2, mAM sts tmang+3, mAL ret
;*******************************************************************************
; Load TmAng To A
;*******************************************************************************
LoadTmAngToA: lds pA, tmang lds mAH, tmang+1 lds mAM, tmang+2 lds mAL, tmang+3 ret
;*******************************************************************************
; Степень х в память.
;*******************************************************************************
AToPowX: sts powx, pA sts powx+1, mAH sts powx+2, mAM sts powx+3, mAL ret
;*******************************************************************************
; Степень х из памяти.
;*******************************************************************************
PowXToA: lds pA, powx lds mAH, powx+1 lds mAM, powx+2 lds mAL, powx+3 ret
;*******************************************************************************
; Факториал в память.
;*******************************************************************************
AToFact:
86 sts fact, pA sts fact+1, mAH sts fact+2, mAM sts fact+3, mAL ret
;*******************************************************************************
; Факториал из памяти в регистр B.
;*******************************************************************************
FactToB: lds pb, fact lds mbH, fact+1 lds mbM, fact+2 lds mbL, fact+3 ret
;*******************************************************************************
; Значение сумматора в память.
;*******************************************************************************
AToSum: sts sumr, pA sts sumr+1, mAH sts sumr+2, mAM sts sumr+3, mAL ret
;*******************************************************************************
; Значение сумматора в регистр Виз памяти.
;*******************************************************************************
SumToB: lds pb, sumr lds mbH, sumr+1 lds mbM, sumr+2 lds mbL, sumr+3 ret
;*******************************************************************************
; A -> X
;*******************************************************************************
AToX: sts acc_x, pA sts acc_x+1, mAH sts acc_x+2, mAM sts acc_x+3, mAL ret
;*******************************************************************************
; X -> A
;*******************************************************************************
XToA: lds pa, acc_x lds maH, acc_x+1 lds maM, acc_x+2 lds maL, acc_x+3 ret
;*******************************************************************************
; A -> Y
87
;*******************************************************************************
AToY: sts acc_y, pA sts acc_y+1, mAH sts acc_y+2, mAM sts acc_y+3, mAL ret
;*******************************************************************************
; Y -> A
;*******************************************************************************
YToA: lds pa, acc_y lds maH, acc_y+1 lds maM, acc_y+2 lds maL, acc_y+3 ret
;*******************************************************************************
; A -> Z
;*******************************************************************************
AToZ: sts acc_z, pA sts acc_z+1, mAH sts acc_z+2, mAM sts acc_z+3, mAL ret
;*******************************************************************************
; Z -> A
;*******************************************************************************
ZToA: lds pa, acc_z lds maH, acc_z+1 lds maM, acc_z+2 lds maL, acc_z+3 ret
;*******************************************************************************
; A -> Azimuth
;*******************************************************************************
AToAzimuth: sts azim, pA sts azim+1, mAH sts azim+2, mAM sts azim+3, mAL ret
;*******************************************************************************
; Azimuth -> A
;*******************************************************************************
AzimuthToA: lds pa, azim lds maH, azim+1 lds maM, azim+2 lds maL, azim+3 ret
88
;*******************************************************************************
; A -> Height
;*******************************************************************************
AToHeight: sts heig, pA sts heig+1, mAH sts heig+2, mAM sts heig+3, mAL ret
;*******************************************************************************
; Azimuth -> A
;*******************************************************************************
HeightToA: lds pa, heig lds maH, heig+1 lds maM, heig+2 lds maL, heig+3 ret
1 2 3 4 5 6 7