Rappel d'une note importante : Le programme officiel de MPI n'évoque la pratique de la programmation que dans sa partie thématique. Il y est dit : "Cette partie... pourra être l'occasion... d'utiliser quelques notions de programmation (algorithme élémentaire : analyse d'un problème simple, instruction conditionnelle alternative ; langage de programmation associé au tableur utilisé en classe.).
Les leçons de Delphi qui suivent vont donc largement au-delà du programme. Le professeur pourra se contenter de montrer comment écrire une macro dans Excel. S'il préfère travailler en Delphi, il retiendra le code nécessaire pour tracer un graphique (transfert des valeurs d'un tableau dans le composant graphique par une boucle, For i := 1 To...) et un exercice sur une instruction conditionnelle(If ... Then...). Le reste pourra être mis à disposition des élèves les plus avancés, afin qu'ils n'aient pas l'impression de perdre leur temps.
Note importante : Le programme officiel de MPI n'évoque la
logique que dans sa partie thématique. Il y est dit : "Cette partie...
pourra être l'occasion... d'utiliser... des portes logiques, de montrer
le principe de l'additionneur...
Pour pouvoir progresser, nous allons nous plonger
quelque peu dans la logique de l'algèbre de Boole.
Les fonctions logiques mathématiques dont nous allons vous parler
peuvent être réalisées (selon la complexité
du montage et la rapidité attendue) avec des interrupteurs électriques
ou des vannes pneumatiques, des circuits intégrés spécialisés
appelés circuits logiques, des microprocesseurs programmables, des
logiciels informatiques...
// Note : Il serait préférable d'appeler s
la variable correspondant à la lampe (s comme solution).
a -> I -> b
qui s'écrit a = b ou s = a
exemple :
L'action sur un interrupteur est toujours supposée du haut vers
le bas. L'interrupteur est toujours représenté dans sa position
de repos. Imaginez un petit ressort sous l'interrupteur.
| a | b | c |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
| a | |||
|---|---|---|---|
| 0 | 1 | ||
| b | 0 | 0 | 0 |
| 1 | 0 | 1 | |
Opération équivalente : la multiplication. a ET b <->
a * b.
Exemple : La tondeuse ne démarre que si je tire le démarreur
ET si je serre la poignée.
Schéma électrique permettant de réaliser cette
fonction, à l'aide de deux boutons poussoirs, montés en parallèle
:
c = a OU b qui s'écrit aussi c = a + b (en admettant que 1 +
1 = 1, puisque la valeur 2 n'existe pas)
| a | |||
|---|---|---|---|
| 0 | 1 | ||
| b | 0 | 0 | 1 |
| 1 | 1 | 1 | |
Exemple : La lampe de l'escalier s'allume si j'agis sur l'interrupteur du premier OU du deuxième étage (ou sur les deux en même temps).
Réalisez un exécutable Delphi, comportant une Form,
et trois Edit. Les Edit 1 et 2 doivent avoir le comportement suivant :
Chaque fois que l'on clique dessus, ils passent du vert au rouge et réciproquement.
Si Edit1 et Edit2 sont rouges (simultanément), alors Edit3 est rouge
; sinon, il reste vert. Vous pouvez employer d'autres couleurs.
Attention, si vous faites un double clic sur un Edit, Delphi croit
que vous voulez écrire du code pour un événement OnChange.
Si vous avez commis cette erreur (source de longues difficultés
pour un élève distrait, distrait car le OnChange est bel
et bien inscrit dans le titre de la procédure), pas de problème
: n'écrivez pas de code et à la prochaine compilation, la
procédure vide sera effacée. Voici l'erreur classique commise
par les distraits :
procedure TForm1.Edit3Change(Sender: TObject);
begin
//c'est faux, car le changement de l'Edit appelle un nouveau changement.
end;
Donc sélectionnez l'Edit et dans l'inspecteur d'objets, Onglet Méthodes, faites un double clic en face de OnClick.
Voici du code qui marcherait :
procedure TForm1.Edit1Click(Sender: TObject);
begin
If (Edit1.Color = clRed) Then Edit1.Color := clLime Else Edit1.Color
:= clRed ;
C'est efficace, mais lourdaud.
Une façon plus élégante de résoudre ce problème pourrait être celle ci :
procedure TForm1.Edit1Click(Sender: TObject);
Var // Ne marche pas, car la variable est créée et mise
à zéro à chaque appel de la procédure
a : Boolean ;
Begin
a := Not(a) ;
If a Then Edit1.Color := clRed Else Edit1.Color := clLime ;
Nous employons une variable booléenne, a. Vous découvrez
qu'en Delphi sa déclaration est obligatoire. Ici, elle est déclarée
en tant que variable locale à la procédure, c'est à
dire que sa valeur est inconnue en dehors du code de cette procédure.
C'est un peu long, mais cela évite des erreurs colossales de programmation.
A chaque appel de la procédure, Not(a) est calculé. Problème
: quelle est la valeur de a à l'appel de la procédure ?
Cela ne marche donc pas. Il est possible de déclarer la variable
a globale pour l'Unit1, mais cela aggrave les risques d'erreur, si la même
lettre a est employée pour représenter des gradeurs différentes.
Il est plus prudent de procéder ainsi :
procedure TForm1.Edit1Click(Sender: TObject);
Const // Ce n'est pas une vraie constante, elle peut changer, mais
elle est créée une fois pour toutes.
a : Boolean = True ;
Begin
a := Not(a) ;
If a Then Edit1.Color := clRed Else Edit1.Color := clGreen ;
La variable a (ne vous laissez pas impressionner par Const) est déclarée et sa valeur fixée lors du premier appel de la procédure ; ensuite, à chaque nouvel appel de la procédure, c'est sa nouvelle valeur qui est employée. Donc True -> False -> True ...
Problème ! Comment connaître les couleurs des deux
premiers Edit, sans tester Edit1.Color, ce qui est un peu lourd ? Il faudrait
que les variables a (et b du deuxième Edit) soient globales.
Deuxième problème : A quel événement associer
le changement de couleur de l'Edit3 ? Deux solutions semblent possibles
:
L'associer aux deux événements OnClick, ce qui revient
à dupliquer le code, chose à éviter car les modifications
en deviennent plus complexes, avec des risques d'erreur supplémentaires.
Ou créer une procédure commune appelée par les 2 EditClick.
Ou encore utiliser un composant Timer (dans l'onglet Système) qui
testera à intervalles réguliers a et b et décidera
de la couleur de Edit3. Le changement se produira avec un peu de retard,
en ce cas.
Décidons d'employer deux variables globales. Ne les appelons
pas a, ni x, y ... car il apparaît un risque d'erreur grave. Si dans
un programme (plus long que celui ci), nous nommons a deux grandeurs différentes,
le programme se comportera de manière chaotique et incompréhensible,
ce qui est très difficile à corriger.
Donc, il faut sortir
Const
a : Boolean = True ;
de sa procédure, et écrire à la place juste après
Implementation :
Const
etatEd1 : Boolean = True ;
ce qui donne dans l'Unit :
implementation
{$R *.DFM}
Const
etatEd1 : Boolean = True ;
etatEd2 : Boolean = True ;
Procedure ChangerEdit3 ;
Begin If (etatEd1 And etatEd2) Then Form1.Edit3.Color := clRed Else
Form1.Edit3.Color := clLime End ;
procedure TForm1.Edit1Click(Sender: TObject);
Begin
etatEd1 := Not(etatEd1) ;
If etatEd1 Then Edit1.Color := clRed Else Edit1.Color := clLime ;
ChangerEdit3 ;
End ;
Et même chose pour procedure TForm1.Edit2Click, pour la méthode
employant une procédure commune. Sinon, placer sur la Form un Timer,
composant non visuel, c'est à dire représenté par
un petit dessin en phase de conception, mais qui disparaît en mode
exécution. Le Timer a une propriété intéressante,
Interval exprimée en millisecondes. Windows est incapable de gérer
des intervalles plus courts que 50 ms ; de plus ceux ci ne sont pas très
réguliers (incertitude d'environ 5%). Pas mal avec des processeurs
tournant à plusieurs centaines de méga hertz. C'est la rançon
de la gestion en parallèle des différents événements,
et d'un certain laxisme, voire d'un laxisme certain, dans sa programmation.
Nous avons acheté des logiciels destinés à l'éducation
nationale qui manifestement employaient ce Timer pour faire des mesures.
Nous tairons leur nom par charité, mais ils sont juste bons à
finir à la poubelle !
Par un double clic sur le timer, ouvrir la procédure procedure
TForm1.Timer1Timer(Sender: TObject);
et y inscrire :
If (coulEd1 And coulEd2) Then Edit3.Color := clRed Else Edit3.Color
:= clLime ;
qui signifie si (coulEd1 Et coulEd2) est vrai, ce qui nécessite
que les deux soient vraies, alors ... sinon ...
Pour les plus rapides, exercice plus complexe :
Vous avez certainement chez vous un éclairage monté
en va et vient, par exemple dans un couloir. L'action sur un des 2 interrupteurs
provoque un changement de l'état allumé ou éteint
de la lampe. Celle-ci sera simulée par l'Edit 3. Si vous voulez
réaliser un va et vient, sachez qu'il vous faut acquérir
2 interrupteurs spéciaux pour va et vient ; ils réalisent
simultanément les fonctions a et a. Ils devraient
donc comporter 4 bornes, mais les 2 bornes d'entrée sont reliées
pour simplifier. Un interrupteur pour va et vient a donc 3 bornes ; il
peut servir d'interrupteur ordinaire ; le contraire n'est pas possible.
// Indications : La fonction logique réalisée par un va
et vient comportant les interrupteurs a et b est : s = a . b + a
. b, ou s = (a Et b) Ou (a ET b).
Donc, dans Procedure ChangerEdit3 ;
il faudrait remplacer
If (etatEd1 And etatEd2), par
If ((etatEd1 AND etatEd2) OR (Not(etatEd1) AND Not(etatEd2)))
ou plus simplement, en appelant a et b les variables booléennes
:
If ((a AND b) OR (Not(a) AND Not(b)))
Vérifiez ce qui se passe si s = a . b + a
. b.
Essayez, ça marche ! Vous pourrez remplacer les couleurs, le vert par du noir, le rouge par du jaune.
Il n'est pas question ici de donner l'ensemble de la syntaxe de
Delphi ; cela prendrait des centaines de pages et vous disposez de l'aide
en ligne équivalente à plusieurs milliers de pages, accessible
par appui sur la touche F1. Sélectionnez un objet, faites F1, vous
aurez l'aide correspondante. Dans le code source que vous écrivez,
sélectionnez un mot, faites F1, vous obtenez les propriétés
de l'objet concerné.
Il a été créé en 1970 par le Suisse
N.Wirth. Il est rigoureux, clair, structuré. Il est un peu moins
rapide que le C, mais plus facile. Le compilateur Delphi est très
rapide. De plus Delphi nous aide lors de l'écriture du code. Nous
avons vu une première façon de faire, qui consiste à
écrire le nom d'un objet suivi d'un point et d'attendre une seconde.
Il en existe d'autres.
Pascal n'est pas sensible à la casse (majuscules ou minuscules).
Tout identificateur, nom de variable, de fonction, de procédure
... doit être déclaré. Chaque identificateur a un type,
déclaré lui aussi. Cela évite de graves erreurs fréquentes
avec des langages moins rigoureux (nous en verrons un exemple dans le cours
sur la réalisation d'un site Internet, lors de l'emploi du langage
JavaScript). Il est possible de changer un type, cela se nomme un transtypage,
mais c'est une action raisonnée et le compilateur vérifie
qu'il n'y a pas d'erreur.
Exemples de déclaration :
Var x : Real ;
Const k : Integer = 3 ; (voir leçon 4, car il ne s'agit pas
réellement d'une constante)
Note importante
: l'usage du mot clé Const a changé avec les nouvelles versions
de Delphi. Il peut maintenant s'agir réellement d'une constante
dont la valeur ne peut changer, mais cela dépend des directives
de compilation. En fait ce type de déclaration était employé
pour forcer l'initialisation des variables locales à une procédure.
| entier | Integer |
| réel | Real |
| booléen | Boolean |
| chaîne de caractères | String |
L'utilisateur peut créer de nouveaux types.
Le type Variant est capable de représenter des valeurs qui changent
de type ; il a été créé pour transmettre des
données à Windows. Il est recommandé si vous aimez
les logiciels qui "plantent".
Les opérations classiques sont possibles. Juste une remarque
: si vous faites c := a / b ; avec a et b entiers, c doit être de
type réel. S'il est déclaré en tant qu'entier le compilateur
détecte immédiatement l'erreur.
c := 25 Div 7 donne 3 (division entière)
c := 25 Mod 7 donne 4 (reste de la division entière)
Affectation : x := 8 range la valeur 8 dans la variable (en fait
une adresse) x
test logique : x = 8 donne True si 8 est effectivement dans x, False dans le cas contraire
instruction composée : Begin instruction1 ; instruction2 ; End ;
instruction conditionnelle : If (test) Then InstructionA Else InstructionB
instruction conditionnelle, variante si de nombreux choix sont possibles : Case ... Of (voir l'aide en ligne)
itération, boucles : For compteur := 1 To 100 Do InstructionC
boucles imbriquées : For i := 1 To 10 Do Begin
For j := 1 To 5 Do Begin
InstructionD ; InstructionE ;
End ; End ;
Procedure Afficher(texteAffichage : String) ;
Begin
Form1.Edit2.Text := texteAffichage ;
End ;
Cette procédure doit être écrite AVANT toute fonction
ou procédure qui l'appellera (l'utilisera). Si c'est impossible,
voir l'aide en ligne au mot clé Forward.
Naturellement, elle n'est correcte que si la fenêtre s'appelle
Form1 et porte un Edit2.
Function Doubler(x : Real) : Real ;
Var
y : Real ;
Begin
y := 2 * x ;
Result := y ;
End ;
Cette fonction se contente de doubler la valeur du Real qu'on lui transmet.
Le résultat en retour est un Real. Nous aurions pu simplifier un
peu en supprimant la variable locale y et en écrivant :
Result := 2 * x ;
Voici un exemple : Un clic sur le Button1 appelle les deux exemples
précédents.
procedure TForm1.Button1Click(Sender: TObject);
Var
z : Real ;
begin
Afficher('L''essai a donné satisfaction') ;
z := Doubler(7) ;
Form1.Edit1.Text := FloatToStr(z) ;
end;
Cela pourrait être plus simple, sans la variable locale z, en
écrivant :
Form1.Edit1.Text := FloatToStr(Doubler(7)) ;
Cette nouvelle procédure doit obligatoirement être écrite après les deux autres. FloatToStr permet le transtypage du Real z au String qui s'affiche dans l'Edit.
Vous venez de voir comment on place une apostrophe dans une chaîne
: texte : String ;
texte := 'C''est un essai' ;
Il faut doubler l'apostrophe, pour que cela ne soit pas compris comme
une fin de chaîne.
Voici quelques instructions de transtypage :
IntToStr ; StrToInt ; FloatToStr ; StrToFloat ; FloatToStrF( ... ), F signifiant que le nombre réel sera formaté (nombre de chiffres, place de la virgule ... ). Voir l'aide en ligne pour ce dernier cas, offrant de nombreuses variantes.
Nous allons apprendre à ajouter un menu déroulant
à une interface. La description qui suit peut laisser à penser
qu'il s'agit d'une tache compliquée, mais il n'en est rien, c'est
au contraire très intuitif.
C'est un composant non visuel, disponible dans l'onglet Standard.
Placez en un sur votre Form, n'importe où, puisqu'il sera invisible.
Effectuez un double clic dessus, la boîte d'édition s'ouvre.
Cliquez sur le rectangle noir puis dans l'inspecteur d'objets, onglet
Propriétés, cliquez sur Caption. Dans la boîte d'édition,
entrez le texte suivant :
&Fichier
Validez, un nouveau rectangle noir apparaît, à droite
du précédent. Faites de même en donnant à la
propriété Caption la valeur &Edition, puis validez.
Revenez sur Edition, et cliquez. Un rectangle apparaît
au-dessous, sur lequel vous cliquez. Donnez à Caption la valeur
Cou&per, puis aux deux Caption suivantes &Copier, Co&ller.
Lorsque vous avez entré le texte &Copier, il s'est affiché
dans le menu déroulant (en mode conception pour l'instant) en tant
que Copier, le C étant souligné. Vous avez créé
ainsi (Delphi vous a un peu aidé) une touche de raccourci. Lorsque
le programme sera en mode exécution, vous déroulerez le menu
Edition
par Alt + E (E étant la lettre soulignée) et déclencherez
Copier
par appui sur C. Donc Alt + E, puis C déclenchent une copie. Pensez
à inclure systématiquement ces touches de raccourci dans
vos programmes : cela peut être utile en cas de panne de la souris,
et certains utilisateurs adorent ces touches de raccourci. Respectez les
conventions Windows dans vos choix ; pour cela, guidez vous sur Delphi,
Word, Excel ...
Il s'agit d'une autre méthode, encore plus directe, d'accéder
aux menus, puisque le déclenchement d'un sous menu ne nécessite
pas de dérouler le menu principal. Sélectionnez Couper,
puis dans l'inspecteur d'objets, onglet Propriétés, allez
à ShortCut, cliquez dessus et déroulez la liste à
droite. Sélectionnez la bonne valeur. La aussi respectez les conventions
de Windows, car beaucoup d'utilisateurs les connaissent par coeur.
Un programme bien conçu doit toujours offrir à son utilisateur plusieurs façons de déclencher une action.
Maintenant, vous disposez d'un superbe menu à l'allure professionnelle,
mais qui ne fait rien !
Reprenez chacun des sous menus, et dans l'onglet Evénement,
sélectionnez OnClick, et par double clic dans le rectangle à
sa droite, ouvrez la procédure correspondante. Vous pouvez aussi
dérouler une liste des procédures compatibles, et choisir
l'une d'elles.
Note : Le programme officiel de MPI demande d'aborder dans la partie
'culture scientifique et technique' quelques éléments de
l'histoire de la numération. Il ajoute : 'Les systèmes à
base 12 et 60 seront évoqués.
Nous allons étudier la numération, c'est à dire l'écriture des nombres, dans les bases 10, 2 et 16. D'autres bases ont été employées, 12, 60, dont il reste quelques traces dans notre vie de tous les jours. Pouvez-vous citer des cas où vous employez ces bases ? Quel est (encore aujourd'hui) leur intérêt ?
Elle est appelée ainsi parce qu'elle emploie 10 chiffres
différents, de 0 à 9.
Considérons le nombre 1789. 1 est le chiffre des milliers ou
103 , 7 celui des centaines ou 102, 8 celui des dizaines
ou 101 et enfin 9 celui des unités ou 100.
Banal direz vous ! Pas si sur. Si cela vous semble évident,
c'est parce que pendant des années vous avez appris à compter
dans cette base, tables d'addition, de soustraction, de multiplication.
En résumé, 1789 = 1 x 1000 + 7 x 100 + 8 x 10 + 9 x 1.
Comment feriez vous pour retrouver les différents chiffres de
ce nombre ?
Il suffit de diviser 1789 par 10, autant de fois que c'est possible.
1789 / 10 = 178 reste 9 ; 178 / 10 = 17 reste 8 ; 17 / 10 = 1 reste
7. Il suffit maintenant de lire ces chiffres à l'envers : 1 puis
7, puis 8 et enfin 9.
Inutile direz vous ? C'est tout à fait exact, mais cela vous permettra, par analogie avec cet exemple trivial, de retrouver les chiffres d'un nombre dans une base quelconque. Car au fait, pourquoi donc travaillons nous en base 10 ? Un lointain ancêtre se serait il un jour servi de ses doigts pour compter ?
Pour un grand nombre de raisons, les ordinateurs n'emploient que
deux chiffres pour compter. Ces deux états différents sont
notés 0 et 1.
Examinons le nombre écrit 1000011 en base 2. Comment s'écrit
il en base 10 ?
Le premier 1 à droite correspond aux unités, ou 20.
Le deuxième 1 correspond aux "deuzaines", soit 21 soit
encore 2 (en base 10). Le dernier 1 correspond à 26,
soit encore 64.
Donc 1000011 en base 2 vaut en base 10 : 1 x 64 + 1 x 2 + 1 x 1 = 67.
Remarque : L'expression "deuzaine" n'est pas encore admise par l'Académie Française.
Comment retrouver les chiffres en base 2, à partir de l'expression
en base 10, 67 ?
La encore, par divisions successives, par 2 cette fois, et en prenant
le dernier quotient, puis tous les restes, de droite à gauche.
Bit vient de l'américain binary digit, chiffre binaire.
Un octet est formé de huit bits. Attention, les informaticiens
appellent souvent un octet Byte ; ne confondez pas avec Bit.
L'intérêt ? Le nombre 1000011, ou 01000011 en base 2,
ou 67 en base 10, est peu commode à lire, d'où l'idée
de regrouper les bits, par 8 car 8 est une puissance de 2.
Le chiffre 1 tout à droite, rang des unités est appelé
bit de poids faible, ou bit 0 (comme l'exposant de 2).
Le chiffre 0 tout à gauche, rang des 27 = 128 est
le bit de poids fort, ou bit 7.
La mémoire vive de votre ordinateur, celle de sa carte vidéo,
celle de son disque dur sont mesurées en octets.
Un octet permet d'écrire les nombres de 0 à 255 (base
10), soit 256, ou 28 valeurs différentes.
Deux octets (16 bits) permettent de stocker 216 soit
Exemples :
Elle emploie 16 chiffres, 0 1 2 3 4 5 6 7 8 9 A B C D E F. F vaut
15 en base 10.
Elle permet d'écrire de façon plus commode les nombres
en base 2, puisqu'un octet correspond à 2 chiffres en base 16.
1000011 =
Donc
Vérification : 43 en base 16 vaut 4 x 16 + 3 x 1, soit 67 en
base 10.
Nous allons étudier les opérations logiques sur les
octets, indispensables pour utiliser les cartes d'acquisition.
Problème : Sur le Port A configuré en sortie, nous
avons branché 8 lampes. Un camarade de classe en a allumé
certaines et d'autres pas, par un programme en Delphi, en écrivant
le nombre n1 sur le Port A. Il vous demande d'allumer la lampe
4 (qu'elle soit précédemment éteinte ou allumée,
peu importe), sans rien changer aux autres, en écrivant un nombre
sur le Port A.
n1 et n2 sont des entiers, écrits sur
1 octet, donc des entiers compris entre 0 et 255 (valeurs incluses).
La solution la plus simple est la suivante :
Le nombre n2 allumant uniquement la lampe 4 est 1 x 24
soit 16 en base 10.
n2 := 16 ;
Candibus.EcrireDansA( n1 OR n2) ;
n2 est le masque ; ceci s'appelle forcer à 1 le bit 4.
Vérifiez, quelle que soit la valeur de n1, c'est à
dire quelles que soient les lampes allumées, que toutes restent
allumées et que la lampe 4 s'allume (si elle était allumée,
elle le reste).
Cette méthode exige que la valeur précédente n1
du nombre envoyé sur le Port A ait été mémorisée.
Il s'agit cette fois d'éteindre la lampe 4 (si elle était
allumée, sinon elle reste éteinte), sans modifier l'état
des autres.
Vérifiez que le bon code est celui ci :
n2 := 16 ;
Candibus.EcrireDansA( n1 AND n2) ;
n2 est le masque ; ceci s'appelle forcer à 0 le
bit 4.
Vous emploierez un composant Timer et un code qui pourrait contenir
les instructions suivantes : Const x : Byte = 1 ; Begin If x = 0 Then x
:= 1 ; P.EcrireDansA(x) ; x := x*2 ; End ;
Nous nous proposons de faire réaliser par nos élèves
un logiciel d'acquisition de données. De bons élèves
auront terminé leur travail en moins d'une heure. Nous aurons le
temps de faire encore d'autres choses dans cette séance.
Créez un nouveau dossier nommé "acquisition" ; dans
ce dossier, ouvrir un sous dossier nommé acquisition1. Tout votre
travail devra impérativement être rangé dans ce sous
dossier.
Nous voulons une interface composée d'un panneau de boutons
et d'éditeurs de texte, pour contrôler l'acquisition, et de
deux graphiques, l'un représentant l'évolution au cours du
temps des deux tensions d'entrée, l'autre le spectre de Fourier
de la tension appliquée à la voie 1.
Ajoutez sur votre Form un composant PhyJiC et nommez-le P.
Nous supposons que vous employez une carte Candibus, et ainsi la librairie nécessaire à la piloter a été chargée.
Par double clic sur le Button Acquérir, ouvrez une procédure
et ajoutez y le code suivant : (Attendez une seconde après avoir
tapé Candibus., pour voir apparaître les fonctions et procédures
disponibles).
nPoints := StrToInt(Edit2.Text) ;
frequence := StrToFloat(Edit1.Text) ;
P.Acquerir(nPoints, frequence) ;
Remarquez qu'une seconde après l'ouverture de la parenthèse
suivant Acquerir, Delphi vous indique le nom et le type de variables attendus.
S'il ne le fait pas, c'est qu'il a déjà détecté
une erreur. Pour trouver cette erreur faites Compiler. Au fait avez vous
pensé à déclarer vos variables ? Cela doit ressembler
à :
Var
nPoints : Integer ; frequence : Real ;
Begin ...
Il faut maintenant transférer les résultats des mesures,
mesure1 et mesure2, dans Series1 et Series2 qui sont les objets employés
par Chart1. Il ne faut pas déclarer ces tableaux, car c'est déjà
fait.
Series1.Clear ; Series2.Clear ; Series3.Clear ;
For i := 0 To (nPoints - 1) Do Begin
Series1.Add(mesure1[i], '', clGreen) ;
Series2.Add(mesure2[i], '', clRed) ; End ;
Candibus.FFT(1, nPoints) ;
For 1 := 0 To (Trunc(nPoints/2)-1) Do
Series3.Add(module[i], '', clLime) ;
Les Series sont des objets, sous forme de tableau, comprenant un nombre, ici un résultat de mesure, un texte de type String, ici vide, d'où les guillemets ouvrant et fermant '', et une couleur. Il est inutile d'afficher le tableau complet obtenu par FFT, puisqu'il présente une symétrie (vous pouvez facilement vous en convaincre). Trunc permet d'obtenir à coup sur un entier, quel que soit le nombre de points.
Il nous restera à améliorer ce logiciel, au cours de la leçon suivante.
Remarquez que nous n'avons pas testé les textes tapés
par l'utilisateur dans les deux Edit. Ce pourrait être n'importe
quoi ; en ce cas Delphi affichera un message d'erreur, puisqu'il sait ce
qu'il doit trouver, un entier, et un réel. C'est le grand avantage
de la déclaration préalable des variables. Mais on pourrait
envisager un traitement plus spécifique.
Nous n'avons pas vérifié le sérieux de la demande.
La bibliothèque Candibus dispose d'une fonction simplifiée
de détection des erreurs : elle retourne un message, dans la variable
avertissement, de type String. Libre à vous d'en faire ce que vous
voulez. Ajoutez à votre code :
StatusBar1.SimpleText := Candibus.avertissement ;
Delphi dispose de fonctions beaucoup plus sophistiquées de gestion des erreurs ; voir l'aide en ligne à Try, Except, Raise et Finally.
Pour l'instant, les axes des abscisses comportent le numéro
du point de mesure, et non la date, ou la fréquence. La fréquence
d'acquisition ne peut pas toujours être rigoureusement égale
à ce qui est demandé. Candibus.frequenceVraie donne la vraie
valeur employée. Le spectre de Fourier complet s'étend de
la fréquence 0 à la frequenceVraie, le tout sur nPoints.
Le pas est donc frequenceVraie/nPoints. Le pas sur l'axe des dates est
t := 1/frequenceVraie. Modifiez votre code ainsi :
Series1.AddXY(i * t, mesure1[i], '', clGreen) ;
Series3.AddXY(i * frequenceVraie/nPoints, module[i], '', clLime) ;
Cette façon de programmer n'est pas astucieuse, car elle risque
de faire faire 1000 fois le même calcul frequenceVraie/nPoints à
Delphi, s'il y a 1000 points mesurés. Mais Delphi est très
malin et lors de la compilation, s'il s'aperçoit de l'erreur, il
effectuera le calcul une seule fois et le mettra en mémoire. Cela
peut se retrouver en mettant un point d'arrêt sur la ligne de code,
par clic dans la gouttière, à gauche du code, en lançant
l'exécution et lors de l'arrêt en faisant Clic droit | Menu
déroulant | Déboguer | Menu déroulant | Voir le CPU.
Le mieux est de faire quotient := frequenceVraie/nPoints, puis
Series3.AddXY(i * quotient, module[i], '', clLime) ;
Pour donner au logiciel un aspect plus professionnel, il faut lui
adjoindre des menus déroulants. Signalons que la bibliothèque
Candibus possède des fonctions ou procédures pour :
Note importante : Le programme officiel de MPI indique dans la colonne
'Culture scientifique et technique' :
Les recommandations précisent : Quelques fonctionnalités
d'un traitement de texte seront utilisées pour réaliser de
courts comptes-rendus écrits (quelques dizaines de lignes au plus)
en incluant des images, des graphiques, des tableaux...
Ce qui est proposé ci-dessous va au-delà. Il s'agit de créer un petit site Internet à contenu scientifique de 3 pages (dont deux peuvent être quasiment vides) et de découvrir la réalisation de liens hyper texte ainsi que la difficulté à transmettre des lettres grecques et des formules. La partie traitant des feuilles de style peut être utile à un navigateur confirmé. Cela lui permettra de télé charger des pages html et de les modifier légèrement, pour obtenir une meilleure qualité d'impression, avec du texte justifié.
La technique d'enseignement proposée consiste à donner
le minimum aux élèves débutants en informatique et
beaucoup plus à ceux qui travaillent déjà très
vite, soit sous forme de tirages, soit en conseillant la visite de ce site.
La réalisation d'un site Internet nécessite plusieurs
étapes, que nous allons aborder dans les pages qui suivent.
Nous créerons un site comportant 3 pages.
La première
doit
obligatoirement se nommer index.html. C'est la convention retenue
par beaucoup de fournisseurs d'accès.
Ainsi, lorsque le visiteur entrera dans son navigateur l'adresse de
votre site, par exemple http://perso.wanadoo.fr/jussiaux.software/, c'est
la première page qui s'ouvrira, ce qui correspond à http://perso.wanadoo.fr/jussiaux.software/index.html.
Sinon, votre visiteur verra l'arborescence de votre site, ce que vous ne souhaitez pas toujours !
ATTENTION
! Contrairement à Windows, les gestionnaires de sites Internet font
la différence entre majuscules et minuscules, pour les noms des
fichiers. Donc il se peut qu'un site testé sur votre disque dur
ne fonctionne plus une fois chez votre hébergeur. Certaines versions
de l'explorateur de Windows proposent de faire la différence majuscules,
minuscules.
Prenez l'habitude d'écrire tous les noms de fichiers en minuscules
(la vérification est plus facile), exemple page2.htm, image1.gif
... Certains logiciels de dessin sauvegardent parfois en image1.GIF Corrigez
dans l'explorateur de Windows tout de suite, avant d'inclure image1 dans
votre document.
Vous pouvez employer un traitement de texte comme Word, mais inutile
de formater le texte (gras, souligné, retrait de première
ligne ...), donc WordPad, ou NotePad suffisent. Ils seront utiles pour
retoucher "à la main" des détails du code HTML.
Vous pouvez pour ce faire employer Netscape Composer, fourni avec
Netscape Communicator. DreamWeaver 2 est aussi disponible gratuitement
(la version payante doit être la 4, mais pour ce que nous allons
faire, celle-ci suffit. Elle permet d'inclure automatiquement des formulaires
dans une page, possibilité que n'offre pas Netscape Composer).
Ouvrez Composer et votre traitement de textes, et transférez par copier coller votre texte. Vous pouvez aussi entrer le texte directement dans Composer. La conversion est automatique.
Procédez maintenant à la mise en page et à l'enrichissement du texte. Dans la barre d'outils, vous disposez d'une liste déroulante Normal, En-Tête1 ... qui permet de formater les titres, sous-titres ...
Utilisez cette technique, plutôt que de changer la taille des caractères. Car dans un usage avancé, avec des feuilles de style, vous pourrez personnaliser très précisément les différents en-têtes, pour tout un ensemble de pages, ce qui conduira à un code plus compact, plus élégant et plus efficace : une modification se répercutera partout à la fois.
Dans Composer, faites Image | Onglet Image | Choisir le fichier,
puis Cliquer sur Taille d'origine (ne vous occupez pas de ce qui se passe),
puis Cliquer sur Autre texte | Entrer votre texte.
En cliquant sur taille d'origine, Composer écrit dans le code
HTML la taille de l'image insérée. Ainsi, le chargement de
la page sera beaucoup plus rapide, car le texte se placera en premier,
les images (évitez de dépasser une taille de 40 kilo-octets)
arrivant par la suite. Le texte alternatif apparaîtra préalablement
à l'image. Un outil utile est l'outil d'alignement, pour centrer
votre image.
Une fois vos pages prêtes, placez y des cibles. Placez votre
curseur au bon endroit, cliquez sur Cible dans la barre d'outils et entrez
un nom. Si une page ne comporte pas de cible, on pourra arriver uniquement
en haut de page.
Ensuite placez les liens : Sélectionner une image, ou une portion de texte | Clic droit | Créer un lien en utilisant la sélection, dans le menu qui s'ouvre | Onglet Lien | Choisir un fichier | Si ce fichier contient des cibles, cliquer sur celle qui vous convient | OK.
Le langage HTML met à votre disposition des outils pour améliorer
la présentation de votre site. Au départ, ce langage a été
conçu pour transmettre des rapports scientifiques, d'où le
nombre d'en-têtes disponibles (6). Vous disposez aussi de tableaux,
bien utiles pour ordonner la page, lorsque celle ci contient des images.
Avec un tableau, il devient possible de placer cote à cote deux
images débordant la largeur de l'écran.
Pour créer un tableau, faites dans Composer Tableau | Propriétés du nouveau tableau | Nombre de lignes ... | Nombre de colonnes ... | Largeur des bords ...
Le tableau peut être rendu invisible (c'est plus discret), avec une largeur des bords égale à 0.
Vous pouvez aussi ajouter à votre page différents composants graphiques, pour créer un formulaire (form), bouton (input type="button"), bouton de validation (input type="submit"), bouton d'effacement des saisies du formulaire (input type="reset"), boîte d'édition (input type="text"), boîte déroulante d'options (select ... option), case à cocher (input type="checkbox"), boutons radio (input type="radio").
Voici un exemple de code, créé en "automatique" à l'aide de DreamWeaver 2 (Composer ne le permet pas). Collez le dans WordPad, sauvegardez le en tant que texte, avec l'extension .htm et examinez la page dans Communicator.
<html>
<head>
<title>Document sans-titre</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>
<body bgcolor="#FFFFFF">
<form method="post" action="" name="">
<input type="button" value="Bouton" name="Bouton">
<input type="text" name="textfield" value="" maxlength="7">
<select name="select" size="1">
<option>Ouvrir</option>
<option>Fermer</option>
<option>Quitter</option>
</select>
<font color="#FFFFFF">
<input type="radio" name="radiobutton" value="Essai1">
<input type="radio" name="radiobutton" value="Essai2" checked>
</font>
</form>
</body>
</html>
Vous avez sauvegardé votre document. Ouvrez le avec WordPad
ou Write, ou même NotePad. Le code créé par Netscape
Composer apparaît. Remarquez qu'il est formé de balises, par
exemple <h2>.......</h2> définit un en-tête de type
2.
Mise en garde : Vous devez respecter les droits de propriété
intellectuelle des auteurs des sites que vous visitez. Lorsque vous aspirez
une page, par exemple pour en extraire des informations, la courtoisie
veut que vous citiez l'auteur du document original. Un travail personnel
encadré ne peut se résumer à une compilation (forcément
disparate) de pages Internet et d'extraits d'encyclopédies.
Il existe des logiciels permettant l'aspiration d'un site entier. Les mêmes règles de respect des droits intellectuels et de courtoisie s'appliquent naturellement.
Avec Netscape, la récupération d'une page, avec les images associées se fait de la manière suivante :
En vous inspirant des pages qui suivent, dans ce chapitre, vous pourriez
modifier le code html, en ajoutant des feuilles de style, pour obtenir
une meilleure qualité d'impression (justification du texte... ).
Réalisez un site Intranet comportant 3 pages (index.htm,
page1.htm et page2.htm) communiquant entre elles.
Veillez à sauvegarder soigneusement votre travail.
Lorsque vous modifiez une page dans Netscape Composer, la modification est-elle immédiatement prise en compte dans le navigateur, Netscape navigator ? Pourquoi ? Comment faire pour provoquer une mise à jour de l'affichage ?
Lorsque vous cliquez sur un lien dans Netscape Composer, que se passe-t-il ? cela vous paraît-il logique ?
Ajoutez à votre site quelques images, soignez la présentation
à l'aide de tableaux (dont les bordures peuvent être invisibles).
Vous pouvez inclure des tableaux à l'intérieur d'autres tableaux.
Quels sont les formats d'images utilisables ? Quels sont les avantages et inconvénients de chacun ? Quelles possibilités d'affichage des images offre Netscape Composer ? La taille, les proportions sont elles variables, est-il possible d'afficher un texte d'attente, y-a-t il des possibilités d'alignement du texte et des images ?
Ajoutez à l'une des pages de votre site une formule simple
employant des lettres grecques (fonte Symbol) et une formule plus complexe,
sous forme d'image. Ajoutez un graphique créé à l'aide
d'un tableur.
// Le format qui convient le mieux est le format compressé Gif. Eventuellement, essayez d'attribuer à votre formule un fond transparent (cela ne sera pas exigible en devoir surveillé).
Notez sur une feuille tout ce que vous savez au sujet d'Einstein.
// Ces connaissances seront mises en commun. Celles qui comportent
de graves erreurs seront critiquées immédiatement. Non Einstein
ne se prénommait pas Franck !
Regroupez sur un document les connaissances initiales de chaque
membre du groupe. Puis recherchez et énoncez clairement les réponses
aux questions suivantes :
