/Modules/PICPGR3/PICPGR301A/SW/4_02/PP_DEFS.PAS
0,0 → 1,525
unit PP_DEFS;
 
{===========================================================================}
{ (c) miho / DECROS 2000 }
{===========================================================================}
{ Zde jsou definice zavisle na vlastnostech jednotlivych procesoru. }
{ Dale jsou zde procedury, ktere prpimo souvisi s definovanymi datovymi }
{ strukturami }
{===========================================================================}
 
interface
 
uses PP_COMON; { jen procedura Error }
 
{===========================================================================}
{ Definice celkoveho rozsahu adresoveho prostoru pri programovani PICu }
{===========================================================================}
 
const DataBufLen=$4000; { Maximalne 2 x 8 K slov pameti programu }
{ dat a konfigurace }
 
{===========================================================================}
{ Definice typu a konstant souvisejicich se zpracovanim prepinacu pro }
{ definovani konfiguracniho slova. }
{===========================================================================}
 
{-- Definice konstant pro rozsah mezi --}
 
const CfgDefProcCount = 5; { pocet skupin procesoru }
CfgDefSwCount = 15; { maximalni pocet prepinacu u jedne skupiny }
CfgWordLen = 14; { maximalni pocet bitu Cfg slova }
CfgNameLen = 10; { maximalni delka jmena definice skupiny }
CfgKeyLen = 10; { maximalni delka prepinace }
 
{-- Definice typu pro popis jednoho prepinace --}
 
type CfgDefSw_t=record
Key : string[CfgKeyLen]; { jmeno prepinace }
On : string[CfgWordLen]; { hodnota pro stav _ON }
Off : string[CfgWordLen]; { hodnota pro stav _OFF }
Bits : string[CfgWordLen]; { definice pro _xxx u vicebitovych prepinacu }
end; {record}
 
{ Key definuje jmeno prepinace ( napr CP pro Code Protection ) }
{ On definuje stav jednotlivych bitu pro stav On }
{ Off definuje stav jednotlivych bity pro stav Off }
{ Bits definuje kam prijdou jednotlive bity vicebitoveho prepinace }
 
const CfgX:string[CfgWordLen]=''; { sama 'X' o delce Cfg slova }
 
{-- Definice typu pro popis jedne skupinu procesoru --}
 
type CfgDefProc_t=record
ProcId : string[CfgNameLen]; { jmeno skupiny procesoru }
Info : array[1..CfgDefSwCount] of CfgDefSw_t;
end; {record}
 
{-- Definice typu pro popis vsech skupin procesoru --}
 
type CfgDef_t=array[1..CfgDefProcCount] of CfgDefProc_t;
 
{-- Definice konstanty popisu prepinace s prazdnym obsahem --}
 
const CfgDefSwNull:CfgDefSw_t=
( Key : '';
On : '';
Off : '';
Bits : ''
);
 
{-- Vlastni definice vsech skupin procesoru --}
 
{$I PP_CFG.PAS} { Abychom tady nemeli tisic radek definice }
 
{===========================================================================}
{ Hlavicky funkci a procedur pro podporu zpracovani prepinacu }
{ modifikujicich konfiguracni slovo. }
{===========================================================================}
 
function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer;
{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==}
{ Pri nenalezeni vraci cilo 0 }
 
procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t);
{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==}
 
procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t);
{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==}
 
function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string;
{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==}
{ prepinace dane skupiny procesoru a vrati vysledek jako }
{ tristavovy retezec. Pri chybe vraci prazdny retezec. }
 
function CfgOr(s1,s2:string):string;
{== Slouci dva Cfg retezce do jednoho. ==}
{ V pripade konfliktu vraci prazdny retezec }
 
function CfgOverride(s,os:string):string;
{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==}
{ V pripade chybneho rozmeru retezcu vraci prazdny retezec }
 
function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string;
{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==}
{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy }
{ retezec. }
{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery }
{ zpusobil chybu na prvni pozici }
 
function Word2Str(W:word):string;
{== Prevede binarni data W na retezec ( tristavovy ) ==}
 
function Str2Word(S:string):word;
{== Prevede Cfg string na binarni data ==}
{ Misto bitu 'X' da '1' }
 
{===========================================================================}
{ Definice typu a konstant popisujicich parametry jednotlivych procesoru. }
{===========================================================================}
 
{-- Definice konstant urcujicich meze -}
 
const ProcName_l = 14; { Maxialni delka jmena procesoru }
ProcCount = 78; { Pocet definovanych procesoru }
 
{-- Definice typu pro identifikaci programovaciho algoritmu --}
 
type ProcAlg_t=
( _NONE_, { Nedefinovana hodnota }
_NON2WIRE_, { Algoritmus neni seriovy ( nepodporuji ) }
{-- EPROM a OTP --}
_EPROM1_, { Stary algoritmus pro EPROM ( PIC12C5xx ) }
_EPROM2_, { Standardni EPROM }
_EPROM3_, { Standardni EPROM se slovem 16 bitu }
{-- EEPROM a FLASH --}
_EE1_, { Standardni Flash / EEPROM }
_EE2_ { Flash / EEPROM s prikazem }
{ Begin Programming Only Cycle }
);
 
{-- Definice typu informace o procesoru --}
 
type ProcNam_t=string[ProcName_l+1];
 
type ProcInfo_t=record
Name : ProcNam_t; { jmeno procesoru }
Alg : ProcAlg_t; { identifikace algoritmu }
Tprog : word; { programovaci cas v us }
Bits : word; { pocet predavanych bitu }
Cfg : string[CfgNameLen]; { druh konfiguracniho slova }
Cfg_Base, Cfg_Mask : word; { adresa Cfg a maska platnych bitu }
PM_Base, PM_Len, PM_Mask : word; { pamet programu }
CM_Base, CM_Len, CM_Mask : word; { pamet konfigurace }
DM_Base, DM_Len, DM_Mask : word; { pamet dat }
end; {record}
 
{-- Defince konstanty parametru procesoru s prazdnym obsahem --}
 
const ProcDummyInfo:ProcInfo_t =
( Name: '';
Alg: _NONE_;
Tprog: 0;
Bits: 0;
Cfg: '';
Cfg_Base: $0000;
Cfg_Mask: $0000;
PM_Base:$0000; PM_Len:$0000; PM_Mask:$0000;
CM_Base:$0000; CM_Len:$0000; CM_Mask:$0000;
DM_Base:$0000; DM_Len:$0000; DM_Mask:$0000
);
 
{-- Defice vlastniho popisu vsech procesoru --}
 
{$I PP_PROC.PAS}
 
{===========================================================================}
{ Hlavicky funkci a procedur souvisejicich s definici parametru procesoru. }
{===========================================================================}
 
procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word);
{== Zobrazi citelne jmeno algoritmu ==}
 
procedure ProcDisplayInfoAll;
{== Zobrazi info o vsech znamych procesorech ==}
{ Strankuje s pauzou }
 
procedure ProcDisplayInfo(ProcInfo:ProcInfo_t);
{== Zobrazi info o jednom procesoru i s nadpisem ==}
 
procedure ProcFind(s:string; var ProcInfo:ProcInfo_t);
{== Najde podle retezce informace o procesoru ==}
 
implementation
 
{===========================================================================}
{ Funkce a procedury pro podporu zpracovani prepinacu modifikujicich }
{ konfiguracni slovo. }
{===========================================================================}
 
function CfgFindProcGroup(Par:string;var CfgDef:CfgDef_t):integer;
{== Vrati index do tabulky CfgDef pro zadane jmeno skupiny procesoru ==}
{ Pri nenalezeni vraci cilo 0 }
var i:integer;
begin i:=CfgDefProcCount+1;
repeat dec(i);
until (i=0) or (Par=CfgDef[i].ProcId);
CfgFindProcGroup:=i;
end; {CfgFindProcGroup}
 
procedure CfgDisplayHelp(var CfgDefProc:CfgDefProc_t);
{== Zobrazi help pro Cfg prepinace zadane skupiny procesoru ==}
var i:integer;
begin write(CfgDefProc.ProcId:10,': ');
for i:=1 to CfgDefSwCount do
write(CfgDefProc.Info[i].Key,' ');
writeln;
end; {CfgDisplayHelp}
 
procedure CfgDisplayHelpAll(var CfgDef:CfgDef_t);
{== Zobrazi help od prepinacu Cfg slova pro vechny skupiny procesoru ==}
var i:integer;
begin writeln('Processor specific switches for Config Word overiding: ');
writeln;
for i:=1 to CfgDefProcCount do
CfgDisplayHelp(CfgDef[i]);
writeln;
end; {CfgDisplayHelpAll}
 
function CfgTestSingleKey(Par:string; Def:CfgDefSw_t):string;
{== Otestuje zda parametr Par odpovida definici Def a vrati retezec ==}
{ obsahujici konfig slovo ve tristavove logice. Pri chybe varci }
{ prazdny retezec }
{ Pomocna funkce }
var i:integer;
BitCount:integer; { pocet bitu 1..8 podle definice }
ParValue:byte; { sem se nactou bity z Par }
begin if pos(Def.Key,Par)=0 then begin CfgTestSingleKey:='';
exit;
end;
if Par=Def.Key+'_ON' then begin CfgTestSingleKey:=Def.On;
exit;
end;
if Par=Def.Key then begin CfgTestSingleKey:=Def.On;
exit;
end;
if Par=Def.Key+'_OFF' then begin CfgTestSingleKey:=Def.Off;
exit;
end;
if Def.Bits='' then begin CfgTestSingleKey:='';
exit;
end;
{-- pocet definovanych bitu --}
BitCount:=0;
for i:=1 to length(Def.Bits) do
begin if (Def.Bits[i] <> 'X') and not (Def.Bits[i] in ['0'..'7'])
then Error('Internal Error 1 at TestKey',0);
if Def.Bits[i] in ['0'..'7']
then if 1+byte(Def.Bits[i])-byte('0') > BitCount
then BitCount:=1+byte(Def.Bits[i])-byte('0');
end;
if BitCount=0 then Error('Internal Error 2 at TestKey',0);
if BitCount>8 then Error('Internal Error 3 at TestKey',0);
if length(Par)<>length(Def.Key)+1+BitCount
then begin CfgTestSingleKey:='';
exit;
end;
{-- precti bity --}
ParValue:=0;
for i:=1 to BitCount do
begin case Par[length(Def.Key)+1+i] of
'0' : ParValue:=ParValue*2;
'1' : ParValue:=ParValue*2+1;
else begin CfgTestSingleKey:='';
exit;
end;
end; {case}
end;
{-- sestav vysledek --}
CfgTestSingleKey[0]:=char(CfgWordLen);
for i:=1 to CfgWordLen do
begin if Def.Bits[i]='X'
then CfgTestSingleKey[i]:='X'
else if ((ParValue shr (byte(Def.Bits[i])-byte('0'))) and 1) = 0
then CfgTestSingleKey[i]:='0'
else CfgTestSingleKey[i]:='1';
end;
end; {CfgTestSingleKey}
 
function CfgTestKey(Par:string;var CfgDefProc:CfgDefProc_t):string;
{== Otestuje parametr ( retezec s jednim prepinacem ) na vsechny ==}
{ prepinace dane skupiny procesoru a vrati vysledek jako }
{ tristavovy retezec. Pri chybe vraci prazdny retezec. }
var i:integer;
s:string;
begin if Par='' then begin CfgTestKey:=''; { to je vlastne chyba, }
exit; { nevracim zadne slovo }
end;
i:=1;
repeat s:=CfgTestSingleKey(Par,CfgDefProc.Info[i]);
inc(i);
until (s<>'') or (i>CfgDefSwCount);
CfgTestKey:=s;
end; {CfgTestKey}
 
procedure CfgDisplayCfgBits(s:string);
{== Zobrazi citelne druh konfiguracnich bitu ==}
{ Pomocna procedura ( ProcDisplayInfoLine ) }
begin write(copy(s+' ',1,9));
end; {CfgDisplayCfgBits}
 
function CfgOr(s1,s2:string):string;
{== Slouci dva Cfg retezce do jednoho. ==}
{ V pripade konfliktu vraci prazdny retezec }
var i:integer;
begin CfgOr:='';
if length(s1)<>length(s2) then exit;
for i:=1 to length(s1) do
case s1[i] of
'0' : case s2[i] of
'0' : CfgOr[i]:='0';
'1' : exit;
'X' : CfgOr[i]:='0';
else exit;
end; {case}
'1' : case s2[i] of
'0' : exit;
'1' : CfgOr[i]:='1';
'X' : CfgOr[i]:='1';
else exit;
end; {case}
'X' : case s2[i] of
'0' : CfgOr[i]:='0';
'1' : CfgOr[i]:='1';
'X' : CfgOr[i]:='X';
else exit;
end; {case}
else exit; { chyba }
end; {case}
CfgOr[0]:=s1[0]; { delka retezce }
end; {CfgOr}
 
function CfgOverride(s,os:string):string;
{== Modifikuje platne Cfg string s platnymi bity Cfg stringu os ==}
{ V pripade chybneho rozmeru retezcu vraci prazdny retezec }
var i:integer;
begin CfgOverride:='';
if length(s)<>length(os) then exit;
for i:=1 to length(s) do
case os[i] of
'0' : CfgOverride[i]:='0';
'1' : CfgOverride[i]:='1';
'X' : CfgOverride[i]:=s[i];
else exit; { chyba }
end; {case}
CfgOverride[0]:=s[0]; { delka retezce }
end; {CfgOverride}
 
function CfgTestKeyMultiple(var Pars:string;var CfgDefProc:CfgDefProc_t):string;
{== Zadavam retezec prepinacu a popis procesorove specifickych prepinacu. ==}
{ Zpracovane parametry z Pars vykousnu. Vracim Cfg slovo jako tristavovy }
{ retezec. }
{ Pokud je chyba, vracim prazdny retezec a v Pars je prepinac, ktery }
{ zpusobil chybu na prvni pozici }
var CfgOne : string; { jeden klic ( prepinac ) }
CfgSuma : string; { mezisoucet klicu }
ErrStr : string; { meziuschova nezpracovatelnych klicu }
begin ErrStr:='';
CfgSuma:=CfgX;
while Pars<>'' do { dokud nezpracuji vse z retezce Pars }
begin {-- zpracuj jeden prepinac --}
CfgOne:=CfgTestKey(GetWord(Pars),CfgDefProc);
if CfgOne=''
then ErrStr:=ErrStr+' '+GetWord(Pars)
else begin CfgSuma:=CfgOr(CfgSuma,CfgOne);
if CfgSuma=''
then begin {-- konfliktni parametry --}
CfgTestKeyMultiple:='';
Pars:=Pars+ErrStr;
exit;
end;
end;
Pars:=DelWord(Pars);
end;
CfgTestKeyMultiple:=CfgSuma; { vysledne konfiguracni slovo }
Pars:=ErrStr; { prepinace, ktere neznam }
end; {CfgTestKeyMultiple}
 
function Word2Str(W:word):string;
{== Prevede binarni data W na retezec ( tristavovy ) ==}
var i:integer;
begin Word2Str[0]:=char(CfgWordLen); { delka retezce }
for i:=CfgWordLen downto 1 do
begin if ( W and 1 ) = 1 then Word2Str[i]:='1' { jednotlive bity }
else Word2Str[i]:='0';
W := W shr 1; { dalsi bit }
end;
end; {Word2Str}
 
function Str2Word(S:string):word;
{== Prevede Cfg string na binarni data ==}
{ Misto bitu 'X' da '1' }
var W:word;
i:integer;
begin W:=0;
for i:=1 to length(S) do
if S[i]<>'0' then W := ( W shl 1 ) + 1
else W := ( W shl 1 );
Str2Word:=W;
end; {Str2Word}
 
{===========================================================================}
{ Funkce a procedury souvisejicich s definici parametru procesoru. }
{===========================================================================}
 
procedure ProcDisplayAlg(Alg:ProcAlg_t;Tprog:word);
{== Zobrazi citelne jmeno algoritmu ==}
begin case Alg of
_NONE_ : write('NONE ');
_EPROM1_ : write('EPROM1 ');
_EPROM2_ : write('EPROM2 ');
_EPROM3_ : write('EPROM3 ');
_EE1_ : write('EE1 ');
_EE2_ : write('EE2 ');
_NON2WIRE_ : write('NON2WIRE');
else write('?? ');
end; {case}
write(Tprog:6,' '); { programovaci cas v us }
end; {ProcDisplayAlg}
 
procedure ProcDisplayInfoLine(ProcInfo:ProcInfo_t);
{== Zobrazi v lidske podobe nektere informace o procesoru ==}
var s:string;
i:integer;
begin s:=ProcInfo.Name;
for i:=length(s)+1 to ProcName_l do s:=s+' ';
write(s,' ');
ProcDisplayAlg(ProcInfo.Alg,ProcInfo.Tprog);
CfgDisplayCfgBits(ProcInfo.Cfg);
DisplayRange(ProcInfo.PM_Base,ProcInfo.PM_Len);
DisplayRange(ProcInfo.CM_Base,ProcInfo.CM_Len);
DisplayRange(ProcInfo.DM_Base,ProcInfo.DM_Len);
writeln;
end; {ProcDisplayInfoLine}
 
procedure ProcDisplayInfoHeader;
{== Zobrazi nadpis ==}
begin writeln('Proc Name Alg Tprog[us] Cfg Bits Pgm Memory Cfg Memory Dat Memory');
writeln('--------------------------------------------------------------------------');
end; {ProcDisplayInfoHeader}
 
procedure ProcDisplayInfoAll;
{== Zobrazi info o vsech znamych procesorech ==}
{ Strankuje s pauzou }
var i,j:integer;
begin i:=0;
while i<ProcCount do
begin ProcDisplayInfoHeader;
j:=0;
while (i<ProcCount) and (j<22) do
begin inc(i);
inc(j);
ProcDisplayInfoLine(ProcInfoAll[i]);
end;
if i<ProcCount then PressEnter;
end;
end; {ProcDisplayInfoAll}
 
procedure ProcDisplayInfo(ProcInfo:ProcInfo_t);
{== Zobrazi info o jednom procesoru i s nadpisem ==}
begin ProcDisplayInfoHeader;
ProcDisplayInfoLine(ProcInfo);
writeln;
end; {ProcDisplayInfo}
 
procedure ProcFind(s:string; var ProcInfo:ProcInfo_t);
{== Najde podle retezce informace o procesoru ==}
var i:integer;
begin {-- separace jmena procesoru z retezce --}
s:=upstr(s)+' ';
ProcInfo:=ProcDummyInfo;
i:=pos('PIC',s);
if i=0 then exit;
s:=copy(s,i,255);
i:=pos(' ',s);
s:=copy(s,1,i-1);
{-- nalezeni informaci --}
for i:=1 to ProcCount do
if (ProcInfoAll[i].Name+' ') = s+' '
then ProcInfo:=ProcInfoAll[i];
end; {ProcFind}
 
{===========================================================================}
{ Telo jednotky. }
{===========================================================================}
 
procedure VerifyProcInfo;
{== Procedura provede interni test konzistentnosti dat ==}
var i:integer;
begin for i:=1 to ProcCount do
with ProcInfoAll[i] do
begin {-- kontrola delky jmena procesoru --}
if length(Name) > ProcName_l
then Error('Internal Error: IE01',0);
{-- kontrola rozsahu pametovych prostoru --}
if PM_Base+PM_Len>DataBufLen
then Error('Internal Error: IE02',0);
if CM_Base+CM_Len>DataBufLen
then Error('Internal Error: IE03',0);
if DM_Base+DM_Len>DataBufLen
then Error('Internal Error: IE04',0);
{-- kontrola zda znam vsechny uvedene Cfg --}
if (ProcInfoAll[i].Cfg<>'') and (CfgFindProcGroup(ProcInfoAll[i].Cfg,CfgDefAll)=0)
then Error('Internal Error: IE5',0);
end;
end; {VerifyProcInfo}
 
var i:integer;
 
begin {-- kontroluje konzistentnost konstant --}
VerifyProcInfo;
{-- inicializace prazdne konstanty pro Cfg slovo ( same 'X' ) --}
CfgX[0]:=char(CfgWordLen);
for i:=1 to length(CfgX) do CfgX[i]:='X';
end.