Discussion :

[Cheebe]

Bonjour,
est-il possible de faire de la programmation parallèle sous Turbo Pascal ?
Par exemple, je souhaite faire circuler une balle et en même temps récupérer les touches frappées par l'utilisateur pour déplacer une "raquette".

Pour info, j'utilise Free Pascal sous XP.

[M.Dlb]

Turbo Pascal ne permet pas de faire de la programmation paralèlle, c'est-à-dire multi-threadée, car à l'origine Turbo Pascal est pour DOS qui est un environnement mono-tâche.

Il faut se tourner vers la programmation pour Windows ou Linux pour avoir des environnements multi-tâches.

Celà, il est tout à fait possible de faire ce que tu indiques, à savoir récupérer les touches en affichant. Il suffit pour celà de donner un "ordre" à ces deux étapes: soit je lis les touches puis j'affiches les résultats, soit j'affiche le résultat précédent puis je lis les touches. Le tout dans une boucle, et ça fonctionne.

A noter que l'on peut utiliser la programmation évènementielle de Turbo Vision, pour gérer l'appui des touches. Il existe un exemple fourni dans Turbo Pascal : breakout.pas

[Stormy_Ordos]

Bonjour,

En DOS pur on pourrait éventuellement utiliser l'interrupteur 1Ch, si les opérations à traiter ne sont pas trop importantes ça peut faire l'affaire.
Par exemple, un programme qui convertirait un fichier texte ASCII pur en ASCII étendu, tout en affichant le pourcentage du fichier traité à l'écran en parallèle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
 
{****************************************************************************
 * Programme de conversion de fichiers ASCII-Dos en ASCII extended pour     *
 * une lecture Windows(prend en charge les accents).                        *
 ****************************************************************************}
 
uses newdelay,crt,dos,mrgnstrn;
 
var  fichier_in, fichier_out : file;
     value                   : byte;
     name_in,name_out        : string;
     old_addr                : pointer;
     Valeur                  : integer;
     Okay                    : boolean;
 
procedure Copie_Octet; interrupt;  {on évite l'overlay grâce à VALEUR, qui est traitée en dehors de 1C}
begin
     Gotoxy(1,1);
     Write(valeur,' % done');
end;
 
 
begin
     Directvideo:=True;
 
     Assigncrt(output);
     ReWrite(output);
     AssignCrt(input);
     ReSet(input);
 
     Repeat
           okay:=true;
           clrscr;
           Write('Input File (ASCII DOS standard) : ');
           Readln(name_in);
           {$I-}
           Assign(fichier_in,name_in);
           Reset(fichier_in,1);
           If (IOResult<>0) then
           begin
                Colwrite('File does not exist or path unknown',Red);
                Writeln;
                Colwrite('Press enter',red);
                Readln;
                Textcolor(White);
                okay:=false;
           end;
           {$I+}
     Until Okay;
 
     Write('Output File : ');
     Readln(name_out);
     Assign(fichier_out,name_out);
     Rewrite(fichier_out,1);
 
     Getintvec($1c,old_addr);      {sauvegarde le gestionnaire 1C}
     Setintvec($1c,@Copie_Octet);  {redirige Addr(1C) sur la proc}
     Clrscr;
     {$I-}
     Repeat
           Blockread(fichier_in,value,1);
           Case value of                   {hexadécimaux correspondants
                                            aux accents}
                      $82 : value:=$E9;
                      $85 : value:=$E0;
                      $94 : value:=$F6;
                      $93 : value:=$F4;
                      $81 : value:=$FC;
                      $96 : value:=$FB;
                      $89 : value:=$EB;
                      $87 : value:=$E7;
                      $88 : value:=$EA;
                      $8B : value:=$EF;
                      $8C : value:=$EE;
                      $83 : value:=$E2;
                      $84 : value:=$E4;
                      $8A : value:=$E8;
                      $B6 : value:=$C2;
                      $8E : value:=$C4;
                      $D2 : value:=$CA;
                      $D3 : value:=$CB;
                      $D7 : value:=$CE;
                      $D8 : value:=$CF;
                      $E2 : value:=$D4;
                      $99 : value:=$D6;
                      $EA : value:=$DB;
                      $9A : value:=$DC;
                      $98 : value:=$FF;
                      $DC : value:=$3D;
 
           end;
           Blockwrite(fichier_out,value,1);
           valeur:=Round((filesize(fichier_out)/filesize(fichier_in))*100);
           {le résultat de VALEUR est ensuite reporté dans 1C }
     until (EOF(fichier_in)) or (filesize(fichier_out)>=filesize(fichier_in));         
     {$I+}
     Gotoxy(1,1);
     Write('100 % done');
     Setintvec($1c,old_addr);       {restaure l'ancien pointeur dans 1C}
end.

Ah oui, l'unité MRGNSTRN n'est absolument pas vitale, c'est juste une bibli de routines utiles comme Colwrite, etc...

Bon évidemment, le traitement est limité, mais tant qu'on ne calcule pas des images ou des bases de données, ça peut être pratique.

[M.Dlb]

D'ailleurs pour les plus acharnés, il est possible de faire un ordonnanceur grâce à l'int 1Ch, et ainsi simuler un environnement multi-tâche, mais c'est du haut-niveau là

[Eric Sigoillot]

D'ailleurs pour les plus acharnés, il est possible de faire un ordonnanceur grâce à l'int 1Ch, et ainsi simuler un environnement multi-tâche, mais c'est du haut-niveau là

Non, il vaut mieux éviter d'user de l'int 1Ch pour faire du multitâche : en effet, l'int 1Ch est une int masquable. On peut donc la désactiver

Il vaut mieux se placer sur l'int non masquable, la NMI. Mais ce n'est pas toujours possible.

En tout cas, se placer sur int 8 est plus judicieux car elle permet de régler le temps qui s'écoule entre deux interruptions, là où la 1C est fixée.

@++

[M.Dlb]

Oui, l'int 8 appele l'int 1Ch, mais c'était juste un exemple