WebSVN – MLAB – Rev 204 – Blame – /Modules/PICPGR3/PICPGR301A/SW/4_02/PP

204

miho

1

unit PP_DEFS;

2

3

{===========================================================================}

4

{ (c) miho / DECROS 2000 }

5

{===========================================================================}

6

{ Zde jsou definice zavisle na vlastnostech jednotlivych procesoru. }

7

{ Dale jsou zde procedury, ktere prpimo souvisi s definovanymi datovymi }

8

{ strukturami }

9

{===========================================================================}

10

11

interface

12

13

uses PP_COMON; { jen procedura Error }

14

15

{===========================================================================}

16

{ Definice celkoveho rozsahu adresoveho prostoru pri programovani PICu }

17

{===========================================================================}

18

19

const DataBufLen=$4000; { Maximalne 2 x 8 K slov pameti programu }

20

{ dat a konfigurace }

21

22

{===========================================================================}

23

{ Definice typu a konstant souvisejicich se zpracovanim prepinacu pro }

24

{ definovani konfiguracniho slova. }

25

{===========================================================================}

26

27

{-- Definice konstant pro rozsah mezi --}

28

29

const CfgDefProcCount = 5; { pocet skupin procesoru }

30

CfgDefSwCount = 15; { maximalni pocet prepinacu u jedne skupiny }

31

CfgWordLen = 14; { maximalni pocet bitu Cfg slova }

32

CfgNameLen = 10; { maximalni delka jmena definice skupiny }

33

CfgKeyLen = 10; { maximalni delka prepinace }

34

35

{-- Definice typu pro popis jednoho prepinace --}

36

37

type CfgDefSw_t=record

38

Key : string[CfgKeyLen]; { jmeno prepinace }

39

On : string[CfgWordLen]; { hodnota pro stav _ON }

40

Off : string[CfgWordLen]; { hodnota pro stav _OFF }

41

Bits : string[CfgWordLen]; { definice pro _xxx u vicebitovych prepinacu }

42

end; {record}

43

44

{ Key definuje jmeno prepinace ( napr CP pro Code Protection ) }

45

{ On definuje stav jednotlivych bitu pro stav On }

46

{ Off definuje stav jednotlivych bity pro stav Off }

47

{ Bits definuje kam prijdou jednotlive bity vicebitoveho prepinace }

48

49

const CfgX:string[CfgWordLen]=''; { sama 'X' o delce Cfg slova }

50

51

{-- Definice typu pro popis jedne skupinu procesoru --}

52

53

type CfgDefProc_t=record

54

ProcId : string[CfgNameLen]; { jmeno skupiny procesoru }

55

Info : array[1..CfgDefSwCount] of CfgDefSw_t;

56

end; {record}

57

58

{-- Definice typu pro popis vsech skupin procesoru --}

59

60

type CfgDef_t=array[1..CfgDefProcCount] of CfgDefProc_t;

61

62

{-- Definice konstanty popisu prepinace s prazdnym obsahem --}

63

64

const CfgDefSwNull:CfgDefSw_t=

65

( Key : '';

66

On : '';

67

Off : '';

68

Bits : ''

69

);

70

71

{-- Vlastni definice vsech skupin procesoru --}

72

73

{$I PP_CFG.PAS} { Abychom tady nemeli tisic radek definice }

74

75

{===========================================================================}

76

{ Hlavicky funkci a procedur pro podporu zpracovani prepinacu }

77

{ modifikujicich konfiguracni slovo. }

78

{===========================================================================}

79

80

function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer;

81

{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==}

82

{ Pri nenalezeni vraci cilo 0 }

83

84

procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t);

85

{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==}

86

87

procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t);

88

{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==}

89

90

function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string;

91

{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==}

92

{ prepinace dane skupiny procesoru a vrati vysledek jako }

93

{ tristavovy retezec. Pri chybe vraci prazdny retezec. }

94

95

function CfgOr(s1,s2:string):string;

96

{== Slouci dva Cfg retezce do jednoho. ==}

97

{ V pripade konfliktu vraci prazdny retezec }

98

99

function CfgOverride(s,os:string):string;

100

{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==}

101

{ V pripade chybneho rozmeru retezcu vraci prazdny retezec }

102

103

function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string;

104

{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==}

105

{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy }

106

{ retezec. }

107

{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery }

108

{ zpusobil chybu na prvni pozici }

109

110

function Word2Str(W:word):string;

111

{== Prevede binarni data W na retezec ( tristavovy ) ==}

112

113

function Str2Word(S:string):word;

114

{== Prevede Cfg string na binarni data ==}

115

{ Misto bitu 'X' da '1' }

116

117

{===========================================================================}

118

{ Definice typu a konstant popisujicich parametry jednotlivych procesoru. }

119

{===========================================================================}

120

121

{-- Definice konstant urcujicich meze -}

122

123

const ProcName_l = 14; { Maxialni delka jmena procesoru }

124

ProcCount = 78; { Pocet definovanych procesoru }

125

126

{-- Definice typu pro identifikaci programovaciho algoritmu --}

127

128

type ProcAlg_t=

129

( _NONE_, { Nedefinovana hodnota }

130

_NON2WIRE_, { Algoritmus neni seriovy ( nepodporuji ) }

131

{-- EPROM a OTP --}

132

_EPROM1_, { Stary algoritmus pro EPROM ( PIC12C5xx ) }

133

_EPROM2_, { Standardni EPROM }

134

_EPROM3_, { Standardni EPROM se slovem 16 bitu }

135

{-- EEPROM a FLASH --}

136

_EE1_, { Standardni Flash / EEPROM }

137

_EE2_ { Flash / EEPROM s prikazem }

138

{ Begin Programming Only Cycle }

139

);

140

141

{-- Definice typu informace o procesoru --}

142

143

type ProcNam_t=string[ProcName_l+1];

144

145

type ProcInfo_t=record

146

Name : ProcNam_t; { jmeno procesoru }

147

Alg : ProcAlg_t; { identifikace algoritmu }

148

Tprog : word; { programovaci cas v us }

149

Bits : word; { pocet predavanych bitu }

150

Cfg : string[CfgNameLen]; { druh konfiguracniho slova }

151

Cfg_Base, Cfg_Mask : word; { adresa Cfg a maska platnych bitu }

152

PM_Base, PM_Len, PM_Mask : word; { pamet programu }

153

CM_Base, CM_Len, CM_Mask : word; { pamet konfigurace }

154

DM_Base, DM_Len, DM_Mask : word; { pamet dat }

155

end; {record}

156

157

{-- Defince konstanty parametru procesoru s prazdnym obsahem --}

158

159

const ProcDummyInfo:ProcInfo_t =

160

( Name: '';

161

Alg: _NONE_;

162

Tprog: 0;

163

Bits: 0;

164

Cfg: '';

165

Cfg_Base: $0000;

166

Cfg_Mask: $0000;

167

PM_Base:$0000; PM_Len:$0000; PM_Mask:$0000;

168

CM_Base:$0000; CM_Len:$0000; CM_Mask:$0000;

169

DM_Base:$0000; DM_Len:$0000; DM_Mask:$0000

170

);

171

172

{-- Defice vlastniho popisu vsech procesoru --}

173

174

{$I PP_PROC.PAS}

175

176

{===========================================================================}

177

{ Hlavicky funkci a procedur souvisejicich s definici parametru procesoru. }

178

{===========================================================================}

179

180

procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word);

181

{== Zobrazi citelne jmeno algoritmu ==}

182

183

procedure ProcDisplayInfoAll;

184

{== Zobrazi info o vsech znamych procesorech ==}

185

{ Strankuje s pauzou }

186

187

procedure ProcDisplayInfo(ProcInfo:ProcInfo_t);

188

{== Zobrazi info o jednom procesoru i s nadpisem ==}

189

190

procedure ProcFind(s:string; var ProcInfo:ProcInfo_t);

191

{== Najde podle retezce informace o procesoru ==}

192

193

implementation

194

195

{===========================================================================}

196

{ Funkce a procedury pro podporu zpracovani prepinacu modifikujicich }

197

{ konfiguracni slovo. }

198

{===========================================================================}

199

200

function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer;

201

{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==}

202

{ Pri nenalezeni vraci cilo 0 }

203

var i:integer;

204

begin i:=CfgDefProcCount+1;

205

repeat dec(i);

206

until (i=0) or (Par=CfgDef[i].ProcId);

207

CfgFindProcGroup:=i;

208

end; {CfgFindProcGroup}

209

210

procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t);

211

{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==}

212

var i:integer;

213

begin write(CfgDefProc.ProcId:10,': ');

214

for i:=1 to CfgDefSwCount do

215

write(CfgDefProc.Info[i].Key,' ');

216

writeln;

217

end; {CfgDisplayHelp}

218

219

procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t);

220

{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==}

221

var i:integer;

222

begin writeln('Processor specific switches for Config Word overiding: ');

223

writeln;

224

for i:=1 to CfgDefProcCount do

225

CfgDisplayHelp(CfgDef[i]);

226

writeln;

227

end; {CfgDisplayHelpAll}

228

229

function CfgTestSingleKey(Par:string; Def:CfgDefSw_t):string;

230

{== Otestuje zda parametr Par odpovida definici Def a vrati retezec ==}

231

{ obsahujici konfig slovo ve tristavove logice. Pri chybe varci }

232

{ prazdny retezec }

233

{ Pomocna funkce }

234

var i:integer;

235

BitCount:integer; { pocet bitu 1..8 podle definice }

236

ParValue:byte; { sem se nactou bity z Par }

237

begin if pos(Def.Key,Par)=0 then begin CfgTestSingleKey:='';

238

exit;

239

end;

240

if Par=Def.Key+'_ON' then begin CfgTestSingleKey:=Def.On;

241

exit;

242

end;

243

if Par=Def.Key then begin CfgTestSingleKey:=Def.On;

244

exit;

245

end;

246

if Par=Def.Key+'_OFF' then begin CfgTestSingleKey:=Def.Off;

247

exit;

248

end;

249

if Def.Bits='' then begin CfgTestSingleKey:='';

250

exit;

251

end;

252

{-- pocet definovanych bitu --}

253

BitCount:=0;

254

for i:=1 to length(Def.Bits) do

255

begin if (Def.Bits[i] <> 'X') and not (Def.Bits[i] in ['0'..'7'])

256

then Error('Internal Error 1 at TestKey',0);

257

if Def.Bits[i] in ['0'..'7']

258

then if 1+byte(Def.Bits[i])-byte('0') > BitCount

259

then BitCount:=1+byte(Def.Bits[i])-byte('0');

260

end;

261

if BitCount=0 then Error('Internal Error 2 at TestKey',0);

262

if BitCount>8 then Error('Internal Error 3 at TestKey',0);

263

if length(Par)<>length(Def.Key)+1+BitCount

264

then begin CfgTestSingleKey:='';

265

exit;

266

end;

267

{-- precti bity --}

268

ParValue:=0;

269

for i:=1 to BitCount do

270

begin case Par[length(Def.Key)+1+i] of

271

'0' : ParValue:=ParValue*2;

272

'1' : ParValue:=ParValue*2+1;

273

else begin CfgTestSingleKey:='';

274

exit;

275

end;

276

end; {case}

277

end;

278

{-- sestav vysledek --}

279

CfgTestSingleKey[0]:=char(CfgWordLen);

280

for i:=1 to CfgWordLen do

281

begin if Def.Bits[i]='X'

282

then CfgTestSingleKey[i]:='X'

283

else if ((ParValue shr (byte(Def.Bits[i])-byte('0'))) and 1) = 0

284

then CfgTestSingleKey[i]:='0'

285

else CfgTestSingleKey[i]:='1';

286

end;

287

end; {CfgTestSingleKey}

288

289

function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string;

290

{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==}

291

{ prepinace dane skupiny procesoru a vrati vysledek jako }

292

{ tristavovy retezec. Pri chybe vraci prazdny retezec. }

293

var i:integer;

294

s:string;

295

begin if Par='' then begin CfgTestKey:=''; { to je vlastne chyba, }

296

exit; { nevracim zadne slovo }

297

end;

298

i:=1;

299

repeat s:=CfgTestSingleKey(Par,CfgDefProc.Info[i]);

300

inc(i);

301

until (s<>'') or (i>CfgDefSwCount);

302

CfgTestKey:=s;

303

end; {CfgTestKey}

304

305

procedure CfgDisplayCfgBits(s:string);

306

{== Zobrazi citelne druh konfiguracnich bitu ==}

307

{ Pomocna procedura ( ProcDisplayInfoLine ) }

308

begin write(copy(s+' ',1,9));

309

end; {CfgDisplayCfgBits}

310

311

function CfgOr(s1,s2:string):string;

312

{== Slouci dva Cfg retezce do jednoho. ==}

313

{ V pripade konfliktu vraci prazdny retezec }

314

var i:integer;

315

begin CfgOr:='';

316

if length(s1)<>length(s2) then exit;

317

for i:=1 to length(s1) do

318

case s1[i] of

319

'0' : case s2[i] of

320

'0' : CfgOr[i]:='0';

321

'1' : exit;

322

'X' : CfgOr[i]:='0';

323

else exit;

324

end; {case}

325

'1' : case s2[i] of

326

'0' : exit;

327

'1' : CfgOr[i]:='1';

328

'X' : CfgOr[i]:='1';

329

else exit;

330

end; {case}

331

'X' : case s2[i] of

332

'0' : CfgOr[i]:='0';

333

'1' : CfgOr[i]:='1';

334

'X' : CfgOr[i]:='X';

335

else exit;

336

end; {case}

337

else exit; { chyba }

338

end; {case}

339

CfgOr[0]:=s1[0]; { delka retezce }

340

end; {CfgOr}

341

342

function CfgOverride(s,os:string):string;

343

{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==}

344

{ V pripade chybneho rozmeru retezcu vraci prazdny retezec }

345

var i:integer;

346

begin CfgOverride:='';

347

if length(s)<>length(os) then exit;

348

for i:=1 to length(s) do

349

case os[i] of

350

'0' : CfgOverride[i]:='0';

351

'1' : CfgOverride[i]:='1';

352

'X' : CfgOverride[i]:=s[i];

353

else exit; { chyba }

354

end; {case}

355

CfgOverride[0]:=s[0]; { delka retezce }

356

end; {CfgOverride}

357

358

function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string;

359

{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==}

360

{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy }

361

{ retezec. }

362

{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery }

363

{ zpusobil chybu na prvni pozici }

364

var CfgOne : string; { jeden klic ( prepinac ) }

365

CfgSuma : string; { mezisoucet klicu }

366

ErrStr : string; { meziuschova nezpracovatelnych klicu }

367

begin ErrStr:='';

368

CfgSuma:=CfgX;

369

while Pars<>'' do { dokud nezpracuji vse z retezce Pars }

370

begin {-- zpracuj jeden prepinac --}

371

CfgOne:=CfgTestKey(GetWord(Pars),CfgDefProc);

372

if CfgOne=''

373

then ErrStr:=ErrStr+' '+GetWord(Pars)

374

else begin CfgSuma:=CfgOr(CfgSuma,CfgOne);

375

if CfgSuma=''

376

then begin {-- konfliktni parametry --}

377

CfgTestKeyMultiple:='';

378

Pars:=Pars+ErrStr;

379

exit;

380

end;

381

end;

382

Pars:=DelWord(Pars);

383

end;

384

CfgTestKeyMultiple:=CfgSuma; { vysledne konfiguracni slovo }

385

Pars:=ErrStr; { prepinace, ktere neznam }

386

end; {CfgTestKeyMultiple}

387

388

function Word2Str(W:word):string;

389

{== Prevede binarni data W na retezec ( tristavovy ) ==}

390

var i:integer;

391

begin Word2Str[0]:=char(CfgWordLen); { delka retezce }

392

for i:=CfgWordLen downto 1 do

393

begin if ( W and 1 ) = 1 then Word2Str[i]:='1' { jednotlive bity }

394

else Word2Str[i]:='0';

395

W := W shr 1; { dalsi bit }

396

end;

397

end; {Word2Str}

398

399

function Str2Word(S:string):word;

400

{== Prevede Cfg string na binarni data ==}

401

{ Misto bitu 'X' da '1' }

402

var W:word;

403

i:integer;

404

begin W:=0;

405

for i:=1 to length(S) do

406

if S[i]<>'0' then W := ( W shl 1 ) + 1

407

else W := ( W shl 1 );

408

Str2Word:=W;

409

end; {Str2Word}

410

411

{===========================================================================}

412

{ Funkce a procedury souvisejicich s definici parametru procesoru. }

413

{===========================================================================}

414

415

procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word);

416

{== Zobrazi citelne jmeno algoritmu ==}

417

begin case Alg of

418

_NONE_ : write('NONE ');

419

_EPROM1_ : write('EPROM1 ');

420

_EPROM2_ : write('EPROM2 ');

421

_EPROM3_ : write('EPROM3 ');

422

_EE1_ : write('EE1 ');

423

_EE2_ : write('EE2 ');

424

_NON2WIRE_ : write('NON2WIRE');

425

else write('?? ');

426

end; {case}

427

write(Tprog:6,' '); { programovaci cas v us }

428

end; {ProcDisplayAlg}

429

430

procedure ProcDisplayInfoLine(ProcInfo:ProcInfo_t);

431

{== Zobrazi v lidske podobe nektere informace o procesoru ==}

432

var s:string;

433

i:integer;

434

begin s:=ProcInfo.Name;

435

for i:=length(s)+1 to ProcName_l do s:=s+' ';

436

write(s,' ');

437

ProcDisplayAlg(ProcInfo.Alg,ProcInfo.Tprog);

438

CfgDisplayCfgBits(ProcInfo.Cfg);

439

DisplayRange(ProcInfo.PM_Base,ProcInfo.PM_Len);

440

DisplayRange(ProcInfo.CM_Base,ProcInfo.CM_Len);

441

DisplayRange(ProcInfo.DM_Base,ProcInfo.DM_Len);

442

writeln;

443

end; {ProcDisplayInfoLine}

444

445

procedure ProcDisplayInfoHeader;

446

{== Zobrazi nadpis ==}

447

begin writeln('Proc Name Alg Tprog[us] Cfg Bits Pgm Memory Cfg Memory Dat Memory');

448

writeln('--------------------------------------------------------------------------');

449

end; {ProcDisplayInfoHeader}

450

451

procedure ProcDisplayInfoAll;

452

{== Zobrazi info o vsech znamych procesorech ==}

453

{ Strankuje s pauzou }

454

var i,j:integer;

455

begin i:=0;

456

while i<ProcCount do

457

begin ProcDisplayInfoHeader;

458

j:=0;

459

while (i<ProcCount) and (j<22) do

460

begin inc(i);

461

inc(j);

462

ProcDisplayInfoLine(ProcInfoAll[i]);

463

end;

464

if i<ProcCount then PressEnter;

465

end;

466

end; {ProcDisplayInfoAll}

467

468

procedure ProcDisplayInfo(ProcInfo:ProcInfo_t);

469

{== Zobrazi info o jednom procesoru i s nadpisem ==}

470

begin ProcDisplayInfoHeader;

471

ProcDisplayInfoLine(ProcInfo);

472

writeln;

473

end; {ProcDisplayInfo}

474

475

procedure ProcFind(s:string; var ProcInfo:ProcInfo_t);

476

{== Najde podle retezce informace o procesoru ==}

477

var i:integer;

478

begin {-- separace jmena procesoru z retezce --}

479

s:=upstr(s)+' ';

480

ProcInfo:=ProcDummyInfo;

481

i:=pos('PIC',s);

482

if i=0 then exit;

483

s:=copy(s,i,255);

484

i:=pos(' ',s);

485

s:=copy(s,1,i-1);

486

{-- nalezeni informaci --}

487

for i:=1 to ProcCount do

488

if (ProcInfoAll[i].Name+' ') = s+' '

489

then ProcInfo:=ProcInfoAll[i];

490

end; {ProcFind}

491

492

{===========================================================================}

493

{ Telo jednotky. }

494

{===========================================================================}

495

496

procedure VerifyProcInfo;

497

{== Procedura provede interni test konzistentnosti dat ==}

498

var i:integer;

499

begin for i:=1 to ProcCount do

500

with ProcInfoAll[i] do

501

begin {-- kontrola delky jmena procesoru --}

502

if length(Name) > ProcName_l

503

then Error('Internal Error: IE01',0);

504

{-- kontrola rozsahu pametovych prostoru --}

505

if PM_Base+PM_Len>DataBufLen

506

then Error('Internal Error: IE02',0);

507

if CM_Base+CM_Len>DataBufLen

508

then Error('Internal Error: IE03',0);

509

if DM_Base+DM_Len>DataBufLen

510

then Error('Internal Error: IE04',0);

511

{-- kontrola zda znam vsechny uvedene Cfg --}

512

if (ProcInfoAll[i].Cfg<>'') and (CfgFindProcGroup(ProcInfoAll[i].Cfg,CfgDefAll)=0)

513

then Error('Internal Error: IE5',0);

514

end;

515

end; {VerifyProcInfo}

516

517

var i:integer;

518

519

begin {-- kontroluje konzistentnost konstant --}

520

VerifyProcInfo;

521

{-- inicializace prazdne konstanty pro Cfg slovo ( same 'X' ) --}

522

CfgX[0]:=char(CfgWordLen);

523

for i:=1 to length(CfgX) do CfgX[i]:='X';

524

end.

525

Subversion Repositories – MLAB

(root)/Modules/PICPGR3/PICPGR301A/SW/4_02/PP_DEFS.PAS

Rev 204