ISSLg
- Cours d'électronique
Le langage PIC Micro
Pascal (PMP)
Navigation> electronique/automatisme/PIC/Pascal
Aperçu très synthétique du langage compilé par PMP.
Pour plus d'infos, voir doc_pic_micro_pascal_16a.pdf
(1Mb)
Les
mots-clés du Pascal.
Les mots suivants sont déjà définis par le langage, vous ne pouvez pas
les utiliser comme nom de programme, de constante, de type, de
variable, de fonction ou de procédure :
ABS,
ABSOLUTE, AND, ARCCOS, ARCSIN, ARCTAN, ARRAY, ASM, ASSIGN, BAUD, BEGIN,
BITS, BOOLEAN, BREAK, BYTE, CASE,
CHAR, CLR, CLRWDT, CODESEG, CONFIG, CONST, CONTINUE, COS, DEC,
DECLARED, DEFINED, DELAY, DELAY_MS,
DELAY_NS, DISPOSE, DIV, DO, DOUBLE, DOWNTO,
DWORD,
EEREAD, EEWRITE, ELSE, END, ERROR,EXCLUDE,
EXIT, EXP, EXTERNAL, FOR, FORWARD, FP_CLR, FP_IOP, FP_OVR,
FP_UND, FREEMEM, FREQUENCY, FUNCTION,
GETMEM, GOTO, HEX, HI, HIGH, IDLOC, IF, IMPLEMENTATION, IN, INC,
INCLUDE, INITIALIZATION, INLINE, INPUT,
INTEGER, INTERFACE, INTERRUPT, LENGTH, LIBRARY, LN, LO, LONGINT,
LONGWORD, LOW, MAXINT, MAXLONGINT,
MAXWORD, MEMAVAIL, MOD, MOD16, MOD16S, MOD32, MOD8, MOVE,
MUL18, NEW, NIL, NOP, NOT, ODD,
OF, ON, OPTION, OR, ORD, OUT, OUTPUT, OVERLOAD, PACKED, PI,
POINTER, POW, PRED, PROCEDURE, PROGRAM,
PWM, READ, READLN, REAL, RECORD, REPEAT, RESET, ROL, ROR, ROUND,
SET, SFR, SHL, SHORTINT, SHR, SIN,
SINGLE, SIZEOF, SLEEP, SQR, SQRT, STR, STRING, SUCC, SWAP,
TAN, THEN, TO, TRIS, TRUNC, TYPE, UNIT,UNTIL,
UPCASE, USES, VAL, VAR, VERSION, VOLATILE, WHILE, WITH, WORD, WRITE,
WRITELN, XOR.
Pour définir vos noms
(programme, constante, type, variable, fonction
ou procédure), vous devez le faire avec une suite de lettres
(a..z, A..Z) de chiffre (0..9) ou le "underscore" (_). Le Pascal ne
fait pas de distinction entre MAJUSCULE et minuscule, mais généralement
les constantes sont en majuscule, les variables en minuscule, les nom
de fonctions et procédure commencent par une majuscule et les types
commencent par un 'T'.
Les
types simples du Pascal.
Électroniquement, le PIC manipule des bytes. Le type fondamental
des variables (ce que l'on manipule) est donc le byte, à partir de
celui-ci le Pascal en a défini d'autres afin de faciliter la
programmation :
BYTE: entier
non signé codé en 8 bits (0..255).
WORD: entier
non signé codé en 16 bits (0..65535).
LONGWORD ou DWORD: entier
non signé codé en 32 bits (0..4294967295).
BOOLEAN:
booléen codé sur un bit (FALSE, TRUE).
NB: SFR: byte localisé à un registre spécifique du PIC.
SHORTINT: entier signé
codé en 8 bits (-128..127).
INTEGER: entier signé
codé en 16 bits (-32768..32767).
LONGINT: entier
non signé codé en 32 bits (-2147483648..2147483647).
Remarque: les nombres négatifs sont représentés en "complément à 2".
ARRAY
OF BYTE|CHAR|SHORTINT|WORD|INTEGER|LONGINT|LONGWORD|SINGLE|REAL:
tableau à une dimension de type simple ci-avant (tous du même type).
Voir déclaration de type ci-dessous.
RECORD:
regroupement de variable de types variés sous un seul nom de variable.
Voir déclaration de type ci-dessous.
CHAR:
caractère codé en 8 bits selon le code ASCII (a..z, A..Z,
0..9, _ + - * / , ; : = ? . / + % ...).
STRING:
chaine de maximum 32 caractères (mots, phrase...).
STRING [n]: chaine
de maximum n(0..255) caractères (mots, phrase...).
Remarque: s[0] représente la longueur de la chaine, s[1] le 1er
caractère, s[2] le 2d caractère...
NB:
il existe également deux types de réels en virgule flottante (SINGLE
et REAL). Mais il vaut mieux les éviter pour des raisons de
lenteur de calcul (par exemple en travaillant en mV avec un type WORD).
La
structure d'un programme Pascal.
Toujours faire les déclarations dans cet ordre :
program test;
{(Options
de compilation)}
{Déclaration
des librairies utilisées}
{Déclaration
des constantes}
{Déclaration
des types}
{Déclaration
des variables}
{Définition
des procédures et fonctions}
{Programme
proprement dit}
begin
{Initialisation du programme}
repeat {
Boucle infinie }
{Instructions du programme}
until false;
end.
La
déclaration des constantes.
Exemples de déclaration de constantes :
const
K = 12;
ALLUME = $FF;
MASK = [0,
4, 3, 7]; {b'10011001'}
MAX = 3
* 4;
MU0 = 4.0E-7
* PI;
NOM = 'Marc';
ACCUEIL = 'Bonjour '
+ NOM;
CODE: array[0..9]
of
byte = ($3F, $06,
$5B, $4F, $66, $6D,
$7D, $07, $7F, $67);
La
déclaration des types.
Exemples de déclaration de types :
type
TJour = (Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche);
TSemaine = array[Lundi..Dimanche]
of
byte;
TInterval = Lundi..Vendredi;
TScolaire = array[TInterval]
of
byte;
TLigne = string[16];
TAfficheur = array[1..2] of
TLigne;
TPosition = record
l,c: byte;
b : boolean;
end;
TObjet = record
x,y : byte;
procedure
Clear;
procedure
Goto;
function
Color : byte;
end;
La
déclaration des variables.
Exemples de déclaration de variables :
var
b : byte;
i,k : integer;
w : word;
l : longint;
f : boolean;
j : TJour;
t : array[-3..7]
of byte;
s : string[10];
lg : TLigne;
p : TPosition;
affich : TAfficheur;
obj : TObjet;
La
déclaration des procedures.
Exemples de déclarations et d'usages de procédures :
procedure
Multiplie (var
prod:word;
f1,f2:byte);
{Déclaration des constantes propres à la procedure}
{Déclaration des types propres à la procedure}
{Déclaration des variables propres à la procedure}
begin
prod := f1;
prod := prod * f2;
end;
procedure
Puissance (var
puis:word;
n,e:byte);
var
i : byte;
begin
puis := 1;
for
i:=1 to e do
puis := puis * n;
end;
{Déclaration d'une procedure d'un objet}
procedure
TObjet.Clear;
begin
x:=0;
y:=0;
end;
...
Multiplie (w,125,100); {w vaut 12500}
Puissance (w,4,5); {w vaut 1024}
obj.Clear;
{obj.x & obj.y vallent 0}
...
La
déclaration des fonctions.
Exemples de déclarations et d'usages de fonctions :
function Mult (f1,f2:byte):word;
{Déclaration des constantes propres à la procedure}
{Déclaration des types propres à la procedure}
{Déclaration des variables propres à la procedure}
begin
Result := f1;
Result
:= Result * f2;
end;
function
Puiss (n,e:byte):word;
var
i : byte;
begin
Result := 1;
for i:=1 to e do
Result
:= Result * n;
end;
...
w := Mult(125,100); {w vaudra 12500}
w := Puiss(4,5); {w vaudra 1024}
Les
opérations sur les booleans.
Il y a 4 opérateurs logiques : NOT, AND, OR, XOR :
var
a,b,c : boolean;
...
b
:= TRUE;
c := FALSE;
a := not(b);
a
:= b and c;
a
:= b or c;
a
:= b xor c;
a
:= not (b and c);
Il y a 6 opérateurs de comparaison d'entiers qui donnent un résultat
boolean : <= , < , = , <> , > ,
>= :
b := i
< 132;
b := i <= 132;
b := i =
512;
b
:= i<>-5;
b :=
PORTA.2=0;
b :=
PORTA.0;
Les
opérations sur les bits.
Normalement pour les entiers non signés : byte, word, longword.
Il
y a 4 opérateurs logiques NOT, AND, OR, XOR qui agissent sur
chaque bit de l'entier non signé :
var
a,b,c : byte;
...
a
:= b and c;
{
Execute :
a.0 := b.0 and c.0;
a.1 := b.1 and c.1;
...
a.7 := b.7 and c.7; }
Il
y a deux opérateurs de décalage des bits shr et shl (ou procédure
ror et rol si report du MSB/LSB) :
a
:= $1A; {a = 0b00011100}
b
:= a shr 2; {b = 0b00000111 décalage à droite de 2
positions}
b
:= a shl 1; {b = 0b00111000 décalage à gauche de 1
position}
Il
y a deux procédures pour
passer de 16 bits en 8 bits Hi, Lo :
var
b : byte;
w : word;
...
b
:= Hi(w); {les 8 MSB}
b
:= Lo(w); {les 8 LSB}
Les
opérations sur les entiers.
Opérateurs arithmétiques classiques : - + *
Division entière : div, mod
Incrémentation, décrémentation : Inc, Dec
var
i : integer;
...
i
:= 5 + (4 - 7)*2; {i=-1}
i := 25 div 10;
{i=2}
i := 25 mod 10;
{i=5}
i:=23;
Inc(i);
{i=24}
Inc(i,3);
{i=27}
i:=27;
Dec(i);
{i=26}
Dec(i,5);
{i=21}
Les
opérations sur les énumérés.
Exemple d'énuméré :
type
TJour = (Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche);
Les
différentes valeurs sont en fait représentées par des
entiers, selon leur ordre de déclaration :
Lundi=0 , Mardi=1 , Mercredi=2 , Jeudi=3 , Vendredi=4 , Samedi=5 ,
Dimanche=6
On
peut donc leur appliquer les mêmes opérations que sur les entiers (voir
ci-avant) ainsi que les opérations de comparaison (< = >
...).
Fonctions utiles : Ord, Pred, Succ, Low, High
Exemples :
var
j,d : TJour;
i : byte;
...
j
:= Jeudi;
i
:= Ord(j); {i=3}
d
:= Pred(j); {d=Mercredi}
d
:=
Succ(j); {d=Vendredi}
i := Low(j); {i=0}
i := High(d); {i=6}
...
Les
opérations sur les chaines de caractères.
Ajout à la suite : +
Fonctions utiles : Length, Str, Hex, Upcase
var
c : char;
s,n : string[20];
i : byte;
...
c
:= Upcase('a'); {c = 'A'}
s
:= '';
{Effacement}
n
:= 'Alfred';
s
:= 'Bonjour ' + n; {s='Bonjour Alfred'}
i :=
Length(s); {i=14}
i
:= s[0];
{i=14}
c :=
s[4]; {c:='j'}
i
:= 254;
s
:= '$' + Hex(i); {s='$FE'}
s
:= Str(i); {s='254'}
Les
conditions.
if
<boolean> then ... (else ...) ;
Exemples :
if b then PORTA:=$FF;
if j<Samedi then
i:=3 else
i:=0; {pas de ; a la fin du then !!!}
if i=5 then
begin
...
end;
if k>=5 then
begin
...
end {pas de ; !!!}
else
begin
...
end;
case
<var_entier> of <valeur> : ... (else
...) end;
Exemples
:
case c of
'A'..'Z' : majuscule:=TRUE;
'a'..'z' : majuscule:=FALSE;
'É' : majuscule:=TRUE;
'é' : majuscule:=FALSE;
'è' : majuscule:=FALSE;
'ê' : majuscule:=FALSE;
...
end;
case h of
0..11 : pm:=FALSE;
12..24 : begin
Dec(h,12);
pm:=TRUE;
end;
else
erreur := TRUE;
end;
Les
boucles.
while <boolean> do
... ;
Exemples
:
i:=0;
while i<5 do
begin
...
Inc(i);
end;
repeat
... until <boolean> ;
Exemples
:
repeat
nop;
until (PORTA.0=1);
for <var_entier>:=<limite_inf> to
<limite_sup> do ... ;
Exemples
:
for i:=-6 to 2 do
begin
... {exécute l'action pour i= -6 -5 -4 -3 -2 -1 0 1 2}
end;
for <var_entier>:=<limite_sup>
downto <limite_inf> do
... ;
Exemples
:
for i:=2 downto 0 do
begin
...
{exécute l'action pour i= 2 1 0}
end;
for <var_entier>:=<limite_inf>
to
<limite_sup> by <increment> do ... ;
Exemples
:
for i:=2 to 16 by 2 do
begin
... {exécute
l'action pour i= 2 4 6 8 10 12 14 16}
end;
Les
librairies.
Structure
d'une librairie :
unit MyLib;
{Doit être enregistrée dans un fichier 'MyLib.pas'}
interface
{Déclaration
des librairies utilisées}
{Déclaration
des constantes}
{Déclaration
des types}
{Déclaration
des variables}
{Déclaration
des procédures et fonctions}
implementation
{Déclaration
des constantes internes}
{Déclaration
des types internes}
{Déclaration
des variables internes}
{Définition
des procédures et fonctions internes}
{Définition
des procédures et fonctions déclarées dans l'interface}
{Initialisation
de la librairie}
Initialization
{Initialisation
des variables}
{Appel des procedures d'initialisation}
end.
Appel
d'une librairie :
program test;
{(Options
de compilation)}
uses
MyLib; {Si plusieurs librairies
utilisées, les séparer par des ','}
{Déclaration
des constantes}
{Déclaration
des types}
{Déclaration
des variables}
{Définition
des procédures et fonctions}
{Programme
proprement dit}
begin
{Initialisation du programme}
repeat {
Boucle infinie }
{Instructions du programme}
until false;
end.
Auteur :
Philippot Marc - 15/01/2014