1 |
unit PP_DEFS; |
1 |
unit PP_DEFS; |
2 |
|
2 |
|
3 |
{===========================================================================} |
3 |
{===========================================================================} |
4 |
{ (c) miho / DECROS 2000 } |
4 |
{ (c) miho / DECROS 2000 } |
5 |
{===========================================================================} |
5 |
{===========================================================================} |
6 |
{ Zde jsou definice zavisle na vlastnostech jednotlivych procesoru. } |
6 |
{ Zde jsou definice zavisle na vlastnostech jednotlivych procesoru. } |
7 |
{ Dale jsou zde procedury, ktere prpimo souvisi s definovanymi datovymi } |
7 |
{ Dale jsou zde procedury, ktere prpimo souvisi s definovanymi datovymi } |
8 |
{ strukturami } |
8 |
{ strukturami } |
9 |
{===========================================================================} |
9 |
{===========================================================================} |
10 |
|
10 |
|
11 |
interface |
11 |
interface |
12 |
|
12 |
|
13 |
uses PP_COMON; { jen procedura Error } |
13 |
uses PP_COMON; { jen procedura Error } |
14 |
|
14 |
|
15 |
{===========================================================================} |
15 |
{===========================================================================} |
16 |
{ Definice celkoveho rozsahu adresoveho prostoru pri programovani PICu } |
16 |
{ Definice celkoveho rozsahu adresoveho prostoru pri programovani PICu } |
17 |
{===========================================================================} |
17 |
{===========================================================================} |
18 |
|
18 |
|
19 |
const DataBufLen=$4000; { Maximalne 2 x 8 K slov pameti programu } |
19 |
const DataBufLen=$4000; { Maximalne 2 x 8 K slov pameti programu } |
20 |
{ dat a konfigurace } |
20 |
{ dat a konfigurace } |
21 |
|
21 |
|
22 |
{===========================================================================} |
22 |
{===========================================================================} |
23 |
{ Definice typu a konstant souvisejicich se zpracovanim prepinacu pro } |
23 |
{ Definice typu a konstant souvisejicich se zpracovanim prepinacu pro } |
24 |
{ definovani konfiguracniho slova. } |
24 |
{ definovani konfiguracniho slova. } |
25 |
{===========================================================================} |
25 |
{===========================================================================} |
26 |
|
26 |
|
27 |
{-- Definice konstant pro rozsah mezi --} |
27 |
{-- Definice konstant pro rozsah mezi --} |
28 |
|
28 |
|
29 |
const CfgDefProcCount = 5; { pocet skupin procesoru } |
29 |
const CfgDefProcCount = 5; { pocet skupin procesoru } |
30 |
CfgDefSwCount = 15; { maximalni pocet prepinacu u jedne skupiny } |
30 |
CfgDefSwCount = 15; { maximalni pocet prepinacu u jedne skupiny } |
31 |
CfgWordLen = 14; { maximalni pocet bitu Cfg slova } |
31 |
CfgWordLen = 14; { maximalni pocet bitu Cfg slova } |
32 |
CfgNameLen = 10; { maximalni delka jmena definice skupiny } |
32 |
CfgNameLen = 10; { maximalni delka jmena definice skupiny } |
33 |
CfgKeyLen = 10; { maximalni delka prepinace } |
33 |
CfgKeyLen = 10; { maximalni delka prepinace } |
34 |
|
34 |
|
35 |
{-- Definice typu pro popis jednoho prepinace --} |
35 |
{-- Definice typu pro popis jednoho prepinace --} |
36 |
|
36 |
|
37 |
type CfgDefSw_t=record |
37 |
type CfgDefSw_t=record |
38 |
Key : string[CfgKeyLen]; { jmeno prepinace } |
38 |
Key : string[CfgKeyLen]; { jmeno prepinace } |
39 |
On : string[CfgWordLen]; { hodnota pro stav _ON } |
39 |
On : string[CfgWordLen]; { hodnota pro stav _ON } |
40 |
Off : string[CfgWordLen]; { hodnota pro stav _OFF } |
40 |
Off : string[CfgWordLen]; { hodnota pro stav _OFF } |
41 |
Bits : string[CfgWordLen]; { definice pro _xxx u vicebitovych prepinacu } |
41 |
Bits : string[CfgWordLen]; { definice pro _xxx u vicebitovych prepinacu } |
42 |
end; {record} |
42 |
end; {record} |
43 |
|
43 |
|
44 |
{ Key definuje jmeno prepinace ( napr CP pro Code Protection ) } |
44 |
{ Key definuje jmeno prepinace ( napr CP pro Code Protection ) } |
45 |
{ On definuje stav jednotlivych bitu pro stav On } |
45 |
{ On definuje stav jednotlivych bitu pro stav On } |
46 |
{ Off definuje stav jednotlivych bity pro stav Off } |
46 |
{ Off definuje stav jednotlivych bity pro stav Off } |
47 |
{ Bits definuje kam prijdou jednotlive bity vicebitoveho prepinace } |
47 |
{ Bits definuje kam prijdou jednotlive bity vicebitoveho prepinace } |
48 |
|
48 |
|
49 |
const CfgX:string[CfgWordLen]=''; { sama 'X' o delce Cfg slova } |
49 |
const CfgX:string[CfgWordLen]=''; { sama 'X' o delce Cfg slova } |
50 |
|
50 |
|
51 |
{-- Definice typu pro popis jedne skupinu procesoru --} |
51 |
{-- Definice typu pro popis jedne skupinu procesoru --} |
52 |
|
52 |
|
53 |
type CfgDefProc_t=record |
53 |
type CfgDefProc_t=record |
54 |
ProcId : string[CfgNameLen]; { jmeno skupiny procesoru } |
54 |
ProcId : string[CfgNameLen]; { jmeno skupiny procesoru } |
55 |
Info : array[1..CfgDefSwCount] of CfgDefSw_t; |
55 |
Info : array[1..CfgDefSwCount] of CfgDefSw_t; |
56 |
end; {record} |
56 |
end; {record} |
57 |
|
57 |
|
58 |
{-- Definice typu pro popis vsech skupin procesoru --} |
58 |
{-- Definice typu pro popis vsech skupin procesoru --} |
59 |
|
59 |
|
60 |
type CfgDef_t=array[1..CfgDefProcCount] of CfgDefProc_t; |
60 |
type CfgDef_t=array[1..CfgDefProcCount] of CfgDefProc_t; |
61 |
|
61 |
|
62 |
{-- Definice konstanty popisu prepinace s prazdnym obsahem --} |
62 |
{-- Definice konstanty popisu prepinace s prazdnym obsahem --} |
63 |
|
63 |
|
64 |
const CfgDefSwNull:CfgDefSw_t= |
64 |
const CfgDefSwNull:CfgDefSw_t= |
65 |
( Key : ''; |
65 |
( Key : ''; |
66 |
On : ''; |
66 |
On : ''; |
67 |
Off : ''; |
67 |
Off : ''; |
68 |
Bits : '' |
68 |
Bits : '' |
69 |
); |
69 |
); |
70 |
|
70 |
|
71 |
{-- Vlastni definice vsech skupin procesoru --} |
71 |
{-- Vlastni definice vsech skupin procesoru --} |
72 |
|
72 |
|
73 |
{$I PP_CFG.PAS} { Abychom tady nemeli tisic radek definice } |
73 |
{$I PP_CFG.PAS} { Abychom tady nemeli tisic radek definice } |
74 |
|
74 |
|
75 |
{===========================================================================} |
75 |
{===========================================================================} |
76 |
{ Hlavicky funkci a procedur pro podporu zpracovani prepinacu } |
76 |
{ Hlavicky funkci a procedur pro podporu zpracovani prepinacu } |
77 |
{ modifikujicich konfiguracni slovo. } |
77 |
{ modifikujicich konfiguracni slovo. } |
78 |
{===========================================================================} |
78 |
{===========================================================================} |
79 |
|
79 |
|
80 |
function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer; |
80 |
function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer; |
81 |
{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==} |
81 |
{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==} |
82 |
{ Pri nenalezeni vraci cilo 0 } |
82 |
{ Pri nenalezeni vraci cilo 0 } |
83 |
|
83 |
|
84 |
procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t); |
84 |
procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t); |
85 |
{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==} |
85 |
{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==} |
86 |
|
86 |
|
87 |
procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t); |
87 |
procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t); |
88 |
{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==} |
88 |
{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==} |
89 |
|
89 |
|
90 |
function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string; |
90 |
function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string; |
91 |
{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==} |
91 |
{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==} |
92 |
{ prepinace dane skupiny procesoru a vrati vysledek jako } |
92 |
{ prepinace dane skupiny procesoru a vrati vysledek jako } |
93 |
{ tristavovy retezec. Pri chybe vraci prazdny retezec. } |
93 |
{ tristavovy retezec. Pri chybe vraci prazdny retezec. } |
94 |
|
94 |
|
95 |
function CfgOr(s1,s2:string):string; |
95 |
function CfgOr(s1,s2:string):string; |
96 |
{== Slouci dva Cfg retezce do jednoho. ==} |
96 |
{== Slouci dva Cfg retezce do jednoho. ==} |
97 |
{ V pripade konfliktu vraci prazdny retezec } |
97 |
{ V pripade konfliktu vraci prazdny retezec } |
98 |
|
98 |
|
99 |
function CfgOverride(s,os:string):string; |
99 |
function CfgOverride(s,os:string):string; |
100 |
{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==} |
100 |
{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==} |
101 |
{ V pripade chybneho rozmeru retezcu vraci prazdny retezec } |
101 |
{ V pripade chybneho rozmeru retezcu vraci prazdny retezec } |
102 |
|
102 |
|
103 |
function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string; |
103 |
function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string; |
104 |
{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==} |
104 |
{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==} |
105 |
{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy } |
105 |
{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy } |
106 |
{ retezec. } |
106 |
{ retezec. } |
107 |
{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery } |
107 |
{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery } |
108 |
{ zpusobil chybu na prvni pozici } |
108 |
{ zpusobil chybu na prvni pozici } |
109 |
|
109 |
|
110 |
function Word2Str(W:word):string; |
110 |
function Word2Str(W:word):string; |
111 |
{== Prevede binarni data W na retezec ( tristavovy ) ==} |
111 |
{== Prevede binarni data W na retezec ( tristavovy ) ==} |
112 |
|
112 |
|
113 |
function Str2Word(S:string):word; |
113 |
function Str2Word(S:string):word; |
114 |
{== Prevede Cfg string na binarni data ==} |
114 |
{== Prevede Cfg string na binarni data ==} |
115 |
{ Misto bitu 'X' da '1' } |
115 |
{ Misto bitu 'X' da '1' } |
116 |
|
116 |
|
117 |
{===========================================================================} |
117 |
{===========================================================================} |
118 |
{ Definice typu a konstant popisujicich parametry jednotlivych procesoru. } |
118 |
{ Definice typu a konstant popisujicich parametry jednotlivych procesoru. } |
119 |
{===========================================================================} |
119 |
{===========================================================================} |
120 |
|
120 |
|
121 |
{-- Definice konstant urcujicich meze -} |
121 |
{-- Definice konstant urcujicich meze -} |
122 |
|
122 |
|
123 |
const ProcName_l = 14; { Maxialni delka jmena procesoru } |
123 |
const ProcName_l = 14; { Maxialni delka jmena procesoru } |
124 |
ProcCount = 78; { Pocet definovanych procesoru } |
124 |
ProcCount = 78; { Pocet definovanych procesoru } |
125 |
|
125 |
|
126 |
{-- Definice typu pro identifikaci programovaciho algoritmu --} |
126 |
{-- Definice typu pro identifikaci programovaciho algoritmu --} |
127 |
|
127 |
|
128 |
type ProcAlg_t= |
128 |
type ProcAlg_t= |
129 |
( _NONE_, { Nedefinovana hodnota } |
129 |
( _NONE_, { Nedefinovana hodnota } |
130 |
_NON2WIRE_, { Algoritmus neni seriovy ( nepodporuji ) } |
130 |
_NON2WIRE_, { Algoritmus neni seriovy ( nepodporuji ) } |
131 |
{-- EPROM a OTP --} |
131 |
{-- EPROM a OTP --} |
132 |
_EPROM1_, { Stary algoritmus pro EPROM ( PIC12C5xx ) } |
132 |
_EPROM1_, { Stary algoritmus pro EPROM ( PIC12C5xx ) } |
133 |
_EPROM2_, { Standardni EPROM } |
133 |
_EPROM2_, { Standardni EPROM } |
134 |
_EPROM3_, { Standardni EPROM se slovem 16 bitu } |
134 |
_EPROM3_, { Standardni EPROM se slovem 16 bitu } |
135 |
{-- EEPROM a FLASH --} |
135 |
{-- EEPROM a FLASH --} |
136 |
_EE1_, { Standardni Flash / EEPROM } |
136 |
_EE1_, { Standardni Flash / EEPROM } |
137 |
_EE2_ { Flash / EEPROM s prikazem } |
137 |
_EE2_ { Flash / EEPROM s prikazem } |
138 |
{ Begin Programming Only Cycle } |
138 |
{ Begin Programming Only Cycle } |
139 |
); |
139 |
); |
140 |
|
140 |
|
141 |
{-- Definice typu informace o procesoru --} |
141 |
{-- Definice typu informace o procesoru --} |
142 |
|
142 |
|
143 |
type ProcNam_t=string[ProcName_l+1]; |
143 |
type ProcNam_t=string[ProcName_l+1]; |
144 |
|
144 |
|
145 |
type ProcInfo_t=record |
145 |
type ProcInfo_t=record |
146 |
Name : ProcNam_t; { jmeno procesoru } |
146 |
Name : ProcNam_t; { jmeno procesoru } |
147 |
Alg : ProcAlg_t; { identifikace algoritmu } |
147 |
Alg : ProcAlg_t; { identifikace algoritmu } |
148 |
Tprog : word; { programovaci cas v us } |
148 |
Tprog : word; { programovaci cas v us } |
149 |
Bits : word; { pocet predavanych bitu } |
149 |
Bits : word; { pocet predavanych bitu } |
150 |
Cfg : string[CfgNameLen]; { druh konfiguracniho slova } |
150 |
Cfg : string[CfgNameLen]; { druh konfiguracniho slova } |
151 |
Cfg_Base, Cfg_Mask : word; { adresa Cfg a maska platnych bitu } |
151 |
Cfg_Base, Cfg_Mask : word; { adresa Cfg a maska platnych bitu } |
152 |
PM_Base, PM_Len, PM_Mask : word; { pamet programu } |
152 |
PM_Base, PM_Len, PM_Mask : word; { pamet programu } |
153 |
CM_Base, CM_Len, CM_Mask : word; { pamet konfigurace } |
153 |
CM_Base, CM_Len, CM_Mask : word; { pamet konfigurace } |
154 |
DM_Base, DM_Len, DM_Mask : word; { pamet dat } |
154 |
DM_Base, DM_Len, DM_Mask : word; { pamet dat } |
155 |
end; {record} |
155 |
end; {record} |
156 |
|
156 |
|
157 |
{-- Defince konstanty parametru procesoru s prazdnym obsahem --} |
157 |
{-- Defince konstanty parametru procesoru s prazdnym obsahem --} |
158 |
|
158 |
|
159 |
const ProcDummyInfo:ProcInfo_t = |
159 |
const ProcDummyInfo:ProcInfo_t = |
160 |
( Name: ''; |
160 |
( Name: ''; |
161 |
Alg: _NONE_; |
161 |
Alg: _NONE_; |
162 |
Tprog: 0; |
162 |
Tprog: 0; |
163 |
Bits: 0; |
163 |
Bits: 0; |
164 |
Cfg: ''; |
164 |
Cfg: ''; |
165 |
Cfg_Base: $0000; |
165 |
Cfg_Base: $0000; |
166 |
Cfg_Mask: $0000; |
166 |
Cfg_Mask: $0000; |
167 |
PM_Base:$0000; PM_Len:$0000; PM_Mask:$0000; |
167 |
PM_Base:$0000; PM_Len:$0000; PM_Mask:$0000; |
168 |
CM_Base:$0000; CM_Len:$0000; CM_Mask:$0000; |
168 |
CM_Base:$0000; CM_Len:$0000; CM_Mask:$0000; |
169 |
DM_Base:$0000; DM_Len:$0000; DM_Mask:$0000 |
169 |
DM_Base:$0000; DM_Len:$0000; DM_Mask:$0000 |
170 |
); |
170 |
); |
171 |
|
171 |
|
172 |
{-- Defice vlastniho popisu vsech procesoru --} |
172 |
{-- Defice vlastniho popisu vsech procesoru --} |
173 |
|
173 |
|
174 |
{$I PP_PROC.PAS} |
174 |
{$I PP_PROC.PAS} |
175 |
|
175 |
|
176 |
{===========================================================================} |
176 |
{===========================================================================} |
177 |
{ Hlavicky funkci a procedur souvisejicich s definici parametru procesoru. } |
177 |
{ Hlavicky funkci a procedur souvisejicich s definici parametru procesoru. } |
178 |
{===========================================================================} |
178 |
{===========================================================================} |
179 |
|
179 |
|
180 |
procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word); |
180 |
procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word); |
181 |
{== Zobrazi citelne jmeno algoritmu ==} |
181 |
{== Zobrazi citelne jmeno algoritmu ==} |
182 |
|
182 |
|
183 |
procedure ProcDisplayInfoAll; |
183 |
procedure ProcDisplayInfoAll; |
184 |
{== Zobrazi info o vsech znamych procesorech ==} |
184 |
{== Zobrazi info o vsech znamych procesorech ==} |
185 |
{ Strankuje s pauzou } |
185 |
{ Strankuje s pauzou } |
186 |
|
186 |
|
187 |
procedure ProcDisplayInfo(ProcInfo:ProcInfo_t); |
187 |
procedure ProcDisplayInfo(ProcInfo:ProcInfo_t); |
188 |
{== Zobrazi info o jednom procesoru i s nadpisem ==} |
188 |
{== Zobrazi info o jednom procesoru i s nadpisem ==} |
189 |
|
189 |
|
190 |
procedure ProcFind(s:string; var ProcInfo:ProcInfo_t); |
190 |
procedure ProcFind(s:string; var ProcInfo:ProcInfo_t); |
191 |
{== Najde podle retezce informace o procesoru ==} |
191 |
{== Najde podle retezce informace o procesoru ==} |
192 |
|
192 |
|
193 |
implementation |
193 |
implementation |
194 |
|
194 |
|
195 |
{===========================================================================} |
195 |
{===========================================================================} |
196 |
{ Funkce a procedury pro podporu zpracovani prepinacu modifikujicich } |
196 |
{ Funkce a procedury pro podporu zpracovani prepinacu modifikujicich } |
197 |
{ konfiguracni slovo. } |
197 |
{ konfiguracni slovo. } |
198 |
{===========================================================================} |
198 |
{===========================================================================} |
199 |
|
199 |
|
200 |
function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer; |
200 |
function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer; |
201 |
{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==} |
201 |
{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==} |
202 |
{ Pri nenalezeni vraci cilo 0 } |
202 |
{ Pri nenalezeni vraci cilo 0 } |
203 |
var i:integer; |
203 |
var i:integer; |
204 |
begin i:=CfgDefProcCount+1; |
204 |
begin i:=CfgDefProcCount+1; |
205 |
repeat dec(i); |
205 |
repeat dec(i); |
206 |
until (i=0) or (Par=CfgDef[i].ProcId); |
206 |
until (i=0) or (Par=CfgDef[i].ProcId); |
207 |
CfgFindProcGroup:=i; |
207 |
CfgFindProcGroup:=i; |
208 |
end; {CfgFindProcGroup} |
208 |
end; {CfgFindProcGroup} |
209 |
|
209 |
|
210 |
procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t); |
210 |
procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t); |
211 |
{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==} |
211 |
{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==} |
212 |
var i:integer; |
212 |
var i:integer; |
213 |
begin write(CfgDefProc.ProcId:10,': '); |
213 |
begin write(CfgDefProc.ProcId:10,': '); |
214 |
for i:=1 to CfgDefSwCount do |
214 |
for i:=1 to CfgDefSwCount do |
215 |
write(CfgDefProc.Info[i].Key,' '); |
215 |
write(CfgDefProc.Info[i].Key,' '); |
216 |
writeln; |
216 |
writeln; |
217 |
end; {CfgDisplayHelp} |
217 |
end; {CfgDisplayHelp} |
218 |
|
218 |
|
219 |
procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t); |
219 |
procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t); |
220 |
{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==} |
220 |
{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==} |
221 |
var i:integer; |
221 |
var i:integer; |
222 |
begin writeln('Processor specific switches for Config Word overiding: '); |
222 |
begin writeln('Processor specific switches for Config Word overiding: '); |
223 |
writeln; |
223 |
writeln; |
224 |
for i:=1 to CfgDefProcCount do |
224 |
for i:=1 to CfgDefProcCount do |
225 |
CfgDisplayHelp(CfgDef[i]); |
225 |
CfgDisplayHelp(CfgDef[i]); |
226 |
writeln; |
226 |
writeln; |
227 |
end; {CfgDisplayHelpAll} |
227 |
end; {CfgDisplayHelpAll} |
228 |
|
228 |
|
229 |
function CfgTestSingleKey(Par:string; Def:CfgDefSw_t):string; |
229 |
function CfgTestSingleKey(Par:string; Def:CfgDefSw_t):string; |
230 |
{== Otestuje zda parametr Par odpovida definici Def a vrati retezec ==} |
230 |
{== Otestuje zda parametr Par odpovida definici Def a vrati retezec ==} |
231 |
{ obsahujici konfig slovo ve tristavove logice. Pri chybe varci } |
231 |
{ obsahujici konfig slovo ve tristavove logice. Pri chybe varci } |
232 |
{ prazdny retezec } |
232 |
{ prazdny retezec } |
233 |
{ Pomocna funkce } |
233 |
{ Pomocna funkce } |
234 |
var i:integer; |
234 |
var i:integer; |
235 |
BitCount:integer; { pocet bitu 1..8 podle definice } |
235 |
BitCount:integer; { pocet bitu 1..8 podle definice } |
236 |
ParValue:byte; { sem se nactou bity z Par } |
236 |
ParValue:byte; { sem se nactou bity z Par } |
237 |
begin if pos(Def.Key,Par)=0 then begin CfgTestSingleKey:=''; |
237 |
begin if pos(Def.Key,Par)=0 then begin CfgTestSingleKey:=''; |
238 |
exit; |
238 |
exit; |
239 |
end; |
239 |
end; |
240 |
if Par=Def.Key+'_ON' then begin CfgTestSingleKey:=Def.On; |
240 |
if Par=Def.Key+'_ON' then begin CfgTestSingleKey:=Def.On; |
241 |
exit; |
241 |
exit; |
242 |
end; |
242 |
end; |
243 |
if Par=Def.Key then begin CfgTestSingleKey:=Def.On; |
243 |
if Par=Def.Key then begin CfgTestSingleKey:=Def.On; |
244 |
exit; |
244 |
exit; |
245 |
end; |
245 |
end; |
246 |
if Par=Def.Key+'_OFF' then begin CfgTestSingleKey:=Def.Off; |
246 |
if Par=Def.Key+'_OFF' then begin CfgTestSingleKey:=Def.Off; |
247 |
exit; |
247 |
exit; |
248 |
end; |
248 |
end; |
249 |
if Def.Bits='' then begin CfgTestSingleKey:=''; |
249 |
if Def.Bits='' then begin CfgTestSingleKey:=''; |
250 |
exit; |
250 |
exit; |
251 |
end; |
251 |
end; |
252 |
{-- pocet definovanych bitu --} |
252 |
{-- pocet definovanych bitu --} |
253 |
BitCount:=0; |
253 |
BitCount:=0; |
254 |
for i:=1 to length(Def.Bits) do |
254 |
for i:=1 to length(Def.Bits) do |
255 |
begin if (Def.Bits[i] <> 'X') and not (Def.Bits[i] in ['0'..'7']) |
255 |
begin if (Def.Bits[i] <> 'X') and not (Def.Bits[i] in ['0'..'7']) |
256 |
then Error('Internal Error 1 at TestKey',0); |
256 |
then Error('Internal Error 1 at TestKey',0); |
257 |
if Def.Bits[i] in ['0'..'7'] |
257 |
if Def.Bits[i] in ['0'..'7'] |
258 |
then if 1+byte(Def.Bits[i])-byte('0') > BitCount |
258 |
then if 1+byte(Def.Bits[i])-byte('0') > BitCount |
259 |
then BitCount:=1+byte(Def.Bits[i])-byte('0'); |
259 |
then BitCount:=1+byte(Def.Bits[i])-byte('0'); |
260 |
end; |
260 |
end; |
261 |
if BitCount=0 then Error('Internal Error 2 at TestKey',0); |
261 |
if BitCount=0 then Error('Internal Error 2 at TestKey',0); |
262 |
if BitCount>8 then Error('Internal Error 3 at TestKey',0); |
262 |
if BitCount>8 then Error('Internal Error 3 at TestKey',0); |
263 |
if length(Par)<>length(Def.Key)+1+BitCount |
263 |
if length(Par)<>length(Def.Key)+1+BitCount |
264 |
then begin CfgTestSingleKey:=''; |
264 |
then begin CfgTestSingleKey:=''; |
265 |
exit; |
265 |
exit; |
266 |
end; |
266 |
end; |
267 |
{-- precti bity --} |
267 |
{-- precti bity --} |
268 |
ParValue:=0; |
268 |
ParValue:=0; |
269 |
for i:=1 to BitCount do |
269 |
for i:=1 to BitCount do |
270 |
begin case Par[length(Def.Key)+1+i] of |
270 |
begin case Par[length(Def.Key)+1+i] of |
271 |
'0' : ParValue:=ParValue*2; |
271 |
'0' : ParValue:=ParValue*2; |
272 |
'1' : ParValue:=ParValue*2+1; |
272 |
'1' : ParValue:=ParValue*2+1; |
273 |
else begin CfgTestSingleKey:=''; |
273 |
else begin CfgTestSingleKey:=''; |
274 |
exit; |
274 |
exit; |
275 |
end; |
275 |
end; |
276 |
end; {case} |
276 |
end; {case} |
277 |
end; |
277 |
end; |
278 |
{-- sestav vysledek --} |
278 |
{-- sestav vysledek --} |
279 |
CfgTestSingleKey[0]:=char(CfgWordLen); |
279 |
CfgTestSingleKey[0]:=char(CfgWordLen); |
280 |
for i:=1 to CfgWordLen do |
280 |
for i:=1 to CfgWordLen do |
281 |
begin if Def.Bits[i]='X' |
281 |
begin if Def.Bits[i]='X' |
282 |
then CfgTestSingleKey[i]:='X' |
282 |
then CfgTestSingleKey[i]:='X' |
283 |
else if ((ParValue shr (byte(Def.Bits[i])-byte('0'))) and 1) = 0 |
283 |
else if ((ParValue shr (byte(Def.Bits[i])-byte('0'))) and 1) = 0 |
284 |
then CfgTestSingleKey[i]:='0' |
284 |
then CfgTestSingleKey[i]:='0' |
285 |
else CfgTestSingleKey[i]:='1'; |
285 |
else CfgTestSingleKey[i]:='1'; |
286 |
end; |
286 |
end; |
287 |
end; {CfgTestSingleKey} |
287 |
end; {CfgTestSingleKey} |
288 |
|
288 |
|
289 |
function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string; |
289 |
function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string; |
290 |
{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==} |
290 |
{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==} |
291 |
{ prepinace dane skupiny procesoru a vrati vysledek jako } |
291 |
{ prepinace dane skupiny procesoru a vrati vysledek jako } |
292 |
{ tristavovy retezec. Pri chybe vraci prazdny retezec. } |
292 |
{ tristavovy retezec. Pri chybe vraci prazdny retezec. } |
293 |
var i:integer; |
293 |
var i:integer; |
294 |
s:string; |
294 |
s:string; |
295 |
begin if Par='' then begin CfgTestKey:=''; { to je vlastne chyba, } |
295 |
begin if Par='' then begin CfgTestKey:=''; { to je vlastne chyba, } |
296 |
exit; { nevracim zadne slovo } |
296 |
exit; { nevracim zadne slovo } |
297 |
end; |
297 |
end; |
298 |
i:=1; |
298 |
i:=1; |
299 |
repeat s:=CfgTestSingleKey(Par,CfgDefProc.Info[i]); |
299 |
repeat s:=CfgTestSingleKey(Par,CfgDefProc.Info[i]); |
300 |
inc(i); |
300 |
inc(i); |
301 |
until (s<>'') or (i>CfgDefSwCount); |
301 |
until (s<>'') or (i>CfgDefSwCount); |
302 |
CfgTestKey:=s; |
302 |
CfgTestKey:=s; |
303 |
end; {CfgTestKey} |
303 |
end; {CfgTestKey} |
304 |
|
304 |
|
305 |
procedure CfgDisplayCfgBits(s:string); |
305 |
procedure CfgDisplayCfgBits(s:string); |
306 |
{== Zobrazi citelne druh konfiguracnich bitu ==} |
306 |
{== Zobrazi citelne druh konfiguracnich bitu ==} |
307 |
{ Pomocna procedura ( ProcDisplayInfoLine ) } |
307 |
{ Pomocna procedura ( ProcDisplayInfoLine ) } |
308 |
begin write(copy(s+' ',1,9)); |
308 |
begin write(copy(s+' ',1,9)); |
309 |
end; {CfgDisplayCfgBits} |
309 |
end; {CfgDisplayCfgBits} |
310 |
|
310 |
|
311 |
function CfgOr(s1,s2:string):string; |
311 |
function CfgOr(s1,s2:string):string; |
312 |
{== Slouci dva Cfg retezce do jednoho. ==} |
312 |
{== Slouci dva Cfg retezce do jednoho. ==} |
313 |
{ V pripade konfliktu vraci prazdny retezec } |
313 |
{ V pripade konfliktu vraci prazdny retezec } |
314 |
var i:integer; |
314 |
var i:integer; |
315 |
begin CfgOr:=''; |
315 |
begin CfgOr:=''; |
316 |
if length(s1)<>length(s2) then exit; |
316 |
if length(s1)<>length(s2) then exit; |
317 |
for i:=1 to length(s1) do |
317 |
for i:=1 to length(s1) do |
318 |
case s1[i] of |
318 |
case s1[i] of |
319 |
'0' : case s2[i] of |
319 |
'0' : case s2[i] of |
320 |
'0' : CfgOr[i]:='0'; |
320 |
'0' : CfgOr[i]:='0'; |
321 |
'1' : exit; |
321 |
'1' : exit; |
322 |
'X' : CfgOr[i]:='0'; |
322 |
'X' : CfgOr[i]:='0'; |
323 |
else exit; |
323 |
else exit; |
324 |
end; {case} |
324 |
end; {case} |
325 |
'1' : case s2[i] of |
325 |
'1' : case s2[i] of |
326 |
'0' : exit; |
326 |
'0' : exit; |
327 |
'1' : CfgOr[i]:='1'; |
327 |
'1' : CfgOr[i]:='1'; |
328 |
'X' : CfgOr[i]:='1'; |
328 |
'X' : CfgOr[i]:='1'; |
329 |
else exit; |
329 |
else exit; |
330 |
end; {case} |
330 |
end; {case} |
331 |
'X' : case s2[i] of |
331 |
'X' : case s2[i] of |
332 |
'0' : CfgOr[i]:='0'; |
332 |
'0' : CfgOr[i]:='0'; |
333 |
'1' : CfgOr[i]:='1'; |
333 |
'1' : CfgOr[i]:='1'; |
334 |
'X' : CfgOr[i]:='X'; |
334 |
'X' : CfgOr[i]:='X'; |
335 |
else exit; |
335 |
else exit; |
336 |
end; {case} |
336 |
end; {case} |
337 |
else exit; { chyba } |
337 |
else exit; { chyba } |
338 |
end; {case} |
338 |
end; {case} |
339 |
CfgOr[0]:=s1[0]; { delka retezce } |
339 |
CfgOr[0]:=s1[0]; { delka retezce } |
340 |
end; {CfgOr} |
340 |
end; {CfgOr} |
341 |
|
341 |
|
342 |
function CfgOverride(s,os:string):string; |
342 |
function CfgOverride(s,os:string):string; |
343 |
{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==} |
343 |
{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==} |
344 |
{ V pripade chybneho rozmeru retezcu vraci prazdny retezec } |
344 |
{ V pripade chybneho rozmeru retezcu vraci prazdny retezec } |
345 |
var i:integer; |
345 |
var i:integer; |
346 |
begin CfgOverride:=''; |
346 |
begin CfgOverride:=''; |
347 |
if length(s)<>length(os) then exit; |
347 |
if length(s)<>length(os) then exit; |
348 |
for i:=1 to length(s) do |
348 |
for i:=1 to length(s) do |
349 |
case os[i] of |
349 |
case os[i] of |
350 |
'0' : CfgOverride[i]:='0'; |
350 |
'0' : CfgOverride[i]:='0'; |
351 |
'1' : CfgOverride[i]:='1'; |
351 |
'1' : CfgOverride[i]:='1'; |
352 |
'X' : CfgOverride[i]:=s[i]; |
352 |
'X' : CfgOverride[i]:=s[i]; |
353 |
else exit; { chyba } |
353 |
else exit; { chyba } |
354 |
end; {case} |
354 |
end; {case} |
355 |
CfgOverride[0]:=s[0]; { delka retezce } |
355 |
CfgOverride[0]:=s[0]; { delka retezce } |
356 |
end; {CfgOverride} |
356 |
end; {CfgOverride} |
357 |
|
357 |
|
358 |
function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string; |
358 |
function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string; |
359 |
{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==} |
359 |
{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==} |
360 |
{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy } |
360 |
{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy } |
361 |
{ retezec. } |
361 |
{ retezec. } |
362 |
{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery } |
362 |
{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery } |
363 |
{ zpusobil chybu na prvni pozici } |
363 |
{ zpusobil chybu na prvni pozici } |
364 |
var CfgOne : string; { jeden klic ( prepinac ) } |
364 |
var CfgOne : string; { jeden klic ( prepinac ) } |
365 |
CfgSuma : string; { mezisoucet klicu } |
365 |
CfgSuma : string; { mezisoucet klicu } |
366 |
ErrStr : string; { meziuschova nezpracovatelnych klicu } |
366 |
ErrStr : string; { meziuschova nezpracovatelnych klicu } |
367 |
begin ErrStr:=''; |
367 |
begin ErrStr:=''; |
368 |
CfgSuma:=CfgX; |
368 |
CfgSuma:=CfgX; |
369 |
while Pars<>'' do { dokud nezpracuji vse z retezce Pars } |
369 |
while Pars<>'' do { dokud nezpracuji vse z retezce Pars } |
370 |
begin {-- zpracuj jeden prepinac --} |
370 |
begin {-- zpracuj jeden prepinac --} |
371 |
CfgOne:=CfgTestKey(GetWord(Pars),CfgDefProc); |
371 |
CfgOne:=CfgTestKey(GetWord(Pars),CfgDefProc); |
372 |
if CfgOne='' |
372 |
if CfgOne='' |
373 |
then ErrStr:=ErrStr+' '+GetWord(Pars) |
373 |
then ErrStr:=ErrStr+' '+GetWord(Pars) |
374 |
else begin CfgSuma:=CfgOr(CfgSuma,CfgOne); |
374 |
else begin CfgSuma:=CfgOr(CfgSuma,CfgOne); |
375 |
if CfgSuma='' |
375 |
if CfgSuma='' |
376 |
then begin {-- konfliktni parametry --} |
376 |
then begin {-- konfliktni parametry --} |
377 |
CfgTestKeyMultiple:=''; |
377 |
CfgTestKeyMultiple:=''; |
378 |
Pars:=Pars+ErrStr; |
378 |
Pars:=Pars+ErrStr; |
379 |
exit; |
379 |
exit; |
380 |
end; |
380 |
end; |
381 |
end; |
381 |
end; |
382 |
Pars:=DelWord(Pars); |
382 |
Pars:=DelWord(Pars); |
383 |
end; |
383 |
end; |
384 |
CfgTestKeyMultiple:=CfgSuma; { vysledne konfiguracni slovo } |
384 |
CfgTestKeyMultiple:=CfgSuma; { vysledne konfiguracni slovo } |
385 |
Pars:=ErrStr; { prepinace, ktere neznam } |
385 |
Pars:=ErrStr; { prepinace, ktere neznam } |
386 |
end; {CfgTestKeyMultiple} |
386 |
end; {CfgTestKeyMultiple} |
387 |
|
387 |
|
388 |
function Word2Str(W:word):string; |
388 |
function Word2Str(W:word):string; |
389 |
{== Prevede binarni data W na retezec ( tristavovy ) ==} |
389 |
{== Prevede binarni data W na retezec ( tristavovy ) ==} |
390 |
var i:integer; |
390 |
var i:integer; |
391 |
begin Word2Str[0]:=char(CfgWordLen); { delka retezce } |
391 |
begin Word2Str[0]:=char(CfgWordLen); { delka retezce } |
392 |
for i:=CfgWordLen downto 1 do |
392 |
for i:=CfgWordLen downto 1 do |
393 |
begin if ( W and 1 ) = 1 then Word2Str[i]:='1' { jednotlive bity } |
393 |
begin if ( W and 1 ) = 1 then Word2Str[i]:='1' { jednotlive bity } |
394 |
else Word2Str[i]:='0'; |
394 |
else Word2Str[i]:='0'; |
395 |
W := W shr 1; { dalsi bit } |
395 |
W := W shr 1; { dalsi bit } |
396 |
end; |
396 |
end; |
397 |
end; {Word2Str} |
397 |
end; {Word2Str} |
398 |
|
398 |
|
399 |
function Str2Word(S:string):word; |
399 |
function Str2Word(S:string):word; |
400 |
{== Prevede Cfg string na binarni data ==} |
400 |
{== Prevede Cfg string na binarni data ==} |
401 |
{ Misto bitu 'X' da '1' } |
401 |
{ Misto bitu 'X' da '1' } |
402 |
var W:word; |
402 |
var W:word; |
403 |
i:integer; |
403 |
i:integer; |
404 |
begin W:=0; |
404 |
begin W:=0; |
405 |
for i:=1 to length(S) do |
405 |
for i:=1 to length(S) do |
406 |
if S[i]<>'0' then W := ( W shl 1 ) + 1 |
406 |
if S[i]<>'0' then W := ( W shl 1 ) + 1 |
407 |
else W := ( W shl 1 ); |
407 |
else W := ( W shl 1 ); |
408 |
Str2Word:=W; |
408 |
Str2Word:=W; |
409 |
end; {Str2Word} |
409 |
end; {Str2Word} |
410 |
|
410 |
|
411 |
{===========================================================================} |
411 |
{===========================================================================} |
412 |
{ Funkce a procedury souvisejicich s definici parametru procesoru. } |
412 |
{ Funkce a procedury souvisejicich s definici parametru procesoru. } |
413 |
{===========================================================================} |
413 |
{===========================================================================} |
414 |
|
414 |
|
415 |
procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word); |
415 |
procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word); |
416 |
{== Zobrazi citelne jmeno algoritmu ==} |
416 |
{== Zobrazi citelne jmeno algoritmu ==} |
417 |
begin case Alg of |
417 |
begin case Alg of |
418 |
_NONE_ : write('NONE '); |
418 |
_NONE_ : write('NONE '); |
419 |
_EPROM1_ : write('EPROM1 '); |
419 |
_EPROM1_ : write('EPROM1 '); |
420 |
_EPROM2_ : write('EPROM2 '); |
420 |
_EPROM2_ : write('EPROM2 '); |
421 |
_EPROM3_ : write('EPROM3 '); |
421 |
_EPROM3_ : write('EPROM3 '); |
422 |
_EE1_ : write('EE1 '); |
422 |
_EE1_ : write('EE1 '); |
423 |
_EE2_ : write('EE2 '); |
423 |
_EE2_ : write('EE2 '); |
424 |
_NON2WIRE_ : write('NON2WIRE'); |
424 |
_NON2WIRE_ : write('NON2WIRE'); |
425 |
else write('?? '); |
425 |
else write('?? '); |
426 |
end; {case} |
426 |
end; {case} |
427 |
write(Tprog:6,' '); { programovaci cas v us } |
427 |
write(Tprog:6,' '); { programovaci cas v us } |
428 |
end; {ProcDisplayAlg} |
428 |
end; {ProcDisplayAlg} |
429 |
|
429 |
|
430 |
procedure ProcDisplayInfoLine(ProcInfo:ProcInfo_t); |
430 |
procedure ProcDisplayInfoLine(ProcInfo:ProcInfo_t); |
431 |
{== Zobrazi v lidske podobe nektere informace o procesoru ==} |
431 |
{== Zobrazi v lidske podobe nektere informace o procesoru ==} |
432 |
var s:string; |
432 |
var s:string; |
433 |
i:integer; |
433 |
i:integer; |
434 |
begin s:=ProcInfo.Name; |
434 |
begin s:=ProcInfo.Name; |
435 |
for i:=length(s)+1 to ProcName_l do s:=s+' '; |
435 |
for i:=length(s)+1 to ProcName_l do s:=s+' '; |
436 |
write(s,' '); |
436 |
write(s,' '); |
437 |
ProcDisplayAlg(ProcInfo.Alg,ProcInfo.Tprog); |
437 |
ProcDisplayAlg(ProcInfo.Alg,ProcInfo.Tprog); |
438 |
CfgDisplayCfgBits(ProcInfo.Cfg); |
438 |
CfgDisplayCfgBits(ProcInfo.Cfg); |
439 |
DisplayRange(ProcInfo.PM_Base,ProcInfo.PM_Len); |
439 |
DisplayRange(ProcInfo.PM_Base,ProcInfo.PM_Len); |
440 |
DisplayRange(ProcInfo.CM_Base,ProcInfo.CM_Len); |
440 |
DisplayRange(ProcInfo.CM_Base,ProcInfo.CM_Len); |
441 |
DisplayRange(ProcInfo.DM_Base,ProcInfo.DM_Len); |
441 |
DisplayRange(ProcInfo.DM_Base,ProcInfo.DM_Len); |
442 |
writeln; |
442 |
writeln; |
443 |
end; {ProcDisplayInfoLine} |
443 |
end; {ProcDisplayInfoLine} |
444 |
|
444 |
|
445 |
procedure ProcDisplayInfoHeader; |
445 |
procedure ProcDisplayInfoHeader; |
446 |
{== Zobrazi nadpis ==} |
446 |
{== Zobrazi nadpis ==} |
447 |
begin writeln('Proc Name Alg Tprog[us] Cfg Bits Pgm Memory Cfg Memory Dat Memory'); |
447 |
begin writeln('Proc Name Alg Tprog[us] Cfg Bits Pgm Memory Cfg Memory Dat Memory'); |
448 |
writeln('--------------------------------------------------------------------------'); |
448 |
writeln('--------------------------------------------------------------------------'); |
449 |
end; {ProcDisplayInfoHeader} |
449 |
end; {ProcDisplayInfoHeader} |
450 |
|
450 |
|
451 |
procedure ProcDisplayInfoAll; |
451 |
procedure ProcDisplayInfoAll; |
452 |
{== Zobrazi info o vsech znamych procesorech ==} |
452 |
{== Zobrazi info o vsech znamych procesorech ==} |
453 |
{ Strankuje s pauzou } |
453 |
{ Strankuje s pauzou } |
454 |
var i,j:integer; |
454 |
var i,j:integer; |
455 |
begin i:=0; |
455 |
begin i:=0; |
456 |
while i<ProcCount do |
456 |
while i<ProcCount do |
457 |
begin ProcDisplayInfoHeader; |
457 |
begin ProcDisplayInfoHeader; |
458 |
j:=0; |
458 |
j:=0; |
459 |
while (i<ProcCount) and (j<22) do |
459 |
while (i<ProcCount) and (j<22) do |
460 |
begin inc(i); |
460 |
begin inc(i); |
461 |
inc(j); |
461 |
inc(j); |
462 |
ProcDisplayInfoLine(ProcInfoAll[i]); |
462 |
ProcDisplayInfoLine(ProcInfoAll[i]); |
463 |
end; |
463 |
end; |
464 |
if i<ProcCount then PressEnter; |
464 |
if i<ProcCount then PressEnter; |
465 |
end; |
465 |
end; |
466 |
end; {ProcDisplayInfoAll} |
466 |
end; {ProcDisplayInfoAll} |
467 |
|
467 |
|
468 |
procedure ProcDisplayInfo(ProcInfo:ProcInfo_t); |
468 |
procedure ProcDisplayInfo(ProcInfo:ProcInfo_t); |
469 |
{== Zobrazi info o jednom procesoru i s nadpisem ==} |
469 |
{== Zobrazi info o jednom procesoru i s nadpisem ==} |
470 |
begin ProcDisplayInfoHeader; |
470 |
begin ProcDisplayInfoHeader; |
471 |
ProcDisplayInfoLine(ProcInfo); |
471 |
ProcDisplayInfoLine(ProcInfo); |
472 |
writeln; |
472 |
writeln; |
473 |
end; {ProcDisplayInfo} |
473 |
end; {ProcDisplayInfo} |
474 |
|
474 |
|
475 |
procedure ProcFind(s:string; var ProcInfo:ProcInfo_t); |
475 |
procedure ProcFind(s:string; var ProcInfo:ProcInfo_t); |
476 |
{== Najde podle retezce informace o procesoru ==} |
476 |
{== Najde podle retezce informace o procesoru ==} |
477 |
var i:integer; |
477 |
var i:integer; |
478 |
begin {-- separace jmena procesoru z retezce --} |
478 |
begin {-- separace jmena procesoru z retezce --} |
479 |
s:=upstr(s)+' '; |
479 |
s:=upstr(s)+' '; |
480 |
ProcInfo:=ProcDummyInfo; |
480 |
ProcInfo:=ProcDummyInfo; |
481 |
i:=pos('PIC',s); |
481 |
i:=pos('PIC',s); |
482 |
if i=0 then exit; |
482 |
if i=0 then exit; |
483 |
s:=copy(s,i,255); |
483 |
s:=copy(s,i,255); |
484 |
i:=pos(' ',s); |
484 |
i:=pos(' ',s); |
485 |
s:=copy(s,1,i-1); |
485 |
s:=copy(s,1,i-1); |
486 |
{-- nalezeni informaci --} |
486 |
{-- nalezeni informaci --} |
487 |
for i:=1 to ProcCount do |
487 |
for i:=1 to ProcCount do |
488 |
if (ProcInfoAll[i].Name+' ') = s+' ' |
488 |
if (ProcInfoAll[i].Name+' ') = s+' ' |
489 |
then ProcInfo:=ProcInfoAll[i]; |
489 |
then ProcInfo:=ProcInfoAll[i]; |
490 |
end; {ProcFind} |
490 |
end; {ProcFind} |
491 |
|
491 |
|
492 |
{===========================================================================} |
492 |
{===========================================================================} |
493 |
{ Telo jednotky. } |
493 |
{ Telo jednotky. } |
494 |
{===========================================================================} |
494 |
{===========================================================================} |
495 |
|
495 |
|
496 |
procedure VerifyProcInfo; |
496 |
procedure VerifyProcInfo; |
497 |
{== Procedura provede interni test konzistentnosti dat ==} |
497 |
{== Procedura provede interni test konzistentnosti dat ==} |
498 |
var i:integer; |
498 |
var i:integer; |
499 |
begin for i:=1 to ProcCount do |
499 |
begin for i:=1 to ProcCount do |
500 |
with ProcInfoAll[i] do |
500 |
with ProcInfoAll[i] do |
501 |
begin {-- kontrola delky jmena procesoru --} |
501 |
begin {-- kontrola delky jmena procesoru --} |
502 |
if length(Name) > ProcName_l |
502 |
if length(Name) > ProcName_l |
503 |
then Error('Internal Error: IE01',0); |
503 |
then Error('Internal Error: IE01',0); |
504 |
{-- kontrola rozsahu pametovych prostoru --} |
504 |
{-- kontrola rozsahu pametovych prostoru --} |
505 |
if PM_Base+PM_Len>DataBufLen |
505 |
if PM_Base+PM_Len>DataBufLen |
506 |
then Error('Internal Error: IE02',0); |
506 |
then Error('Internal Error: IE02',0); |
507 |
if CM_Base+CM_Len>DataBufLen |
507 |
if CM_Base+CM_Len>DataBufLen |
508 |
then Error('Internal Error: IE03',0); |
508 |
then Error('Internal Error: IE03',0); |
509 |
if DM_Base+DM_Len>DataBufLen |
509 |
if DM_Base+DM_Len>DataBufLen |
510 |
then Error('Internal Error: IE04',0); |
510 |
then Error('Internal Error: IE04',0); |
511 |
{-- kontrola zda znam vsechny uvedene Cfg --} |
511 |
{-- kontrola zda znam vsechny uvedene Cfg --} |
512 |
if (ProcInfoAll[i].Cfg<>'') and (CfgFindProcGroup(ProcInfoAll[i].Cfg,CfgDefAll)=0) |
512 |
if (ProcInfoAll[i].Cfg<>'') and (CfgFindProcGroup(ProcInfoAll[i].Cfg,CfgDefAll)=0) |
513 |
then Error('Internal Error: IE5',0); |
513 |
then Error('Internal Error: IE5',0); |
514 |
end; |
514 |
end; |
515 |
end; {VerifyProcInfo} |
515 |
end; {VerifyProcInfo} |
516 |
|
516 |
|
517 |
var i:integer; |
517 |
var i:integer; |
518 |
|
518 |
|
519 |
begin {-- kontroluje konzistentnost konstant --} |
519 |
begin {-- kontroluje konzistentnost konstant --} |
520 |
VerifyProcInfo; |
520 |
VerifyProcInfo; |
521 |
{-- inicializace prazdne konstanty pro Cfg slovo ( same 'X' ) --} |
521 |
{-- inicializace prazdne konstanty pro Cfg slovo ( same 'X' ) --} |
522 |
CfgX[0]:=char(CfgWordLen); |
522 |
CfgX[0]:=char(CfgWordLen); |
523 |
for i:=1 to length(CfgX) do CfgX[i]:='X'; |
523 |
for i:=1 to length(CfgX) do CfgX[i]:='X'; |
524 |
end. |
524 |
end. |
525 |
|
525 |
|