Conversion C++ 1990 à Dev C++

Version imprimable

1 pièce(s) jointe(s)

Bonjour à tous,
Y a-t-il quelqu’un qui pourrait me renseigner sur un ancien programme que j’avais fait dans les années 1993 et que je voudrais reprendre sur dev c++, apparemment beaucoup de problème avec le graphisme le code est est si dessous ou en pièce jointe :

Code:

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
/***************************************************************************
Programme : digitalisation pour TARM
Auteur    : ROBER SERGE
Date      : 30/10/1993
****************************************************************************/
#include <dos.h>
#include <stdlib.h>
#include <string.h>
#include <io.h>
#include <ctype.h>
#include <graphics.h>
#include <stdio.h>
#include <conio.h>
#include <bios.h>
 
short cpt=0,np=0,xdp=0,bl,bll,apd;
int xd,yd,sx,sy,vid,da,dp,dap,v=0,col=12;
FILE *in;
void fload();
void fquit();
 
main()
{
int code,cara;
if (_setvideomode(_VRES16COLOR) !=0)
 {
 _clearscreen(_GCLEARSCREEN);
 _setcliprgn(0,0,639,479);
 _rectangle(_GBORDER,0,0,639,479);
 _rectangle(_GBORDER,479,0,479,479);
 _rectangle(_GBORDER,479,35,639,35);
 _rectangle(_GBORDER,479,230,639,230);
 _settextcolor(15);
 _settextposition(2,67);
 _outtext("DISPLAY\n");
 _settextcolor(11);
 _settextposition(4,62);
 _outtext("Name   :");
 _settextposition(6,62);
 _outtext("Nb pts :");
 _settextposition(6,71);
  printf("%d",np);
 _settextposition(8,62);
 _outtext("Blanck :");
 _settextcolor(15);
 _settextposition(11,67);
 _outtext("RS Laser");
 _settextposition(13,63);
 _outtext("Copyright 1994(c)");
 _settextcolor(11);
 _settextposition(17,62);
 _outtext("F1 : Load");
 _settextposition(18,62);
 _outtext("F2 : Quit");
 _settextposition(20,62);
 _outtext("Nb XY  :");
 _settextposition(21,62);
 _outtext("Coord X:    Y:");
 _settextposition(22,62);
 _outtext("Nb Delt:");
 _settextposition(23,62);
 _outtext("Delta X:    Y:");
 
 
 while((cara=getch())!= '\r')
   if(cara != 0) {}
 
     else
      {
       code=getch();
       if (code==59) fload();
       else if (code==60) {_setvideomode(_DEFAULTMODE);break;}
       else continue;
       }
 
 _setvideomode(_DEFAULTMODE);
 }
  else
   {
    _setvideomode(_DEFAULTMODE);
    printf ("MODE VIDEO NON SUPPORTE\n");
    }
}
/***************************************************************************
                         CHARGEMENT DES IMAGES
****************************************************************************/
void fload()
 
{
int a=0x11,b=0x10,c=15,cpt,sw=0,dx,dy,tes=0,test=0,nd=0,nde=0;
fpos_t  posi;
short x,xx,rx,y,yy,ty,xy,ry,np,ex,ey;
FILE *fichier;
char ligne[8];
np=0;
_settextposition(4,71);
_outtext("        ");
_settextcolor(15);
_settextposition(27,04);
_outtext("8 LETTRES MAX.");
_settextposition(28,04);
_outtext("Entrez le nom du fichier :");
_settextcolor(11);
 gets(ligne);
_setcliprgn(1,1,478,478);
_clearscreen(_GVIEWPORT);
_settextposition(4,71);
 printf("%s",ligne);
  if((fichier=fopen(ligne,"r"))==NULL)
   {
      _settextposition(28,10);
      _outtext("Impossible d'ouvrir le fichier");
      return;
   }
rewind(fichier);
while(!feof(fichier))
  {  xy=fgetc(fichier);
     for ( ; sw!=1 ; xy=fgetc(fichier) )
/****************************************************************************
                       RECHERCHE & CALCUL DE LA MATRIX
****************************************************************************/
	 if(xy==a)sw=1;
     if(xy==a){}
	else
	  {
	     for (cpt=1 ; !feof(fichier) && xy!=a ; cpt++)
		 {
		    if (cpt==1)
		       {
			 x=xy;
			 if(x<127)xx=x+128;
			   else xx=x-128;
		       }
		    else if (cpt==2)
		      {
			y=xy;
			if(y<127)yy=y+128;
			  else yy=y-128;
			    ty=255-yy;
			    rx=xx*1.8710937;
			    ry=ty*1.8710937;
			    np=np+1;
			    nd=nd+1;
			    _settextposition(21,71);
			     printf("%X",x);
			    _settextposition(21,77);
			     printf("%X",y);
			    _settextposition(20,71);
			    printf("%d",nd);
			    _setcolor(c);
			    _setpixel(rx,ry);
		      }
		    else if (cpt>=3)
		      {
			if(xy==0x10)
			  {
			     xy=fgetc(fichier);
			     if(xy==0x80)
				  {
				     _settextposition(8,71);
				     printf("OPEN ");
				     c=15;
				     xy=fgetc(fichier);
				 }
			     if(xy==0x00)
			     {
			       _settextposition(8,71);
			       printf("CLOSE");
			       c=10;
			       xy=fgetc(fichier);
			   }
			 }
			if(xy==00) {}
			   else
			     {
				dx=xy/b;
				dy=xy%b;
				ex=dx-8;
				ey=dy-8;
				xx=xx+ex;
				yy=yy+ey;
				ty=255-yy;
				rx=xx*1.8710937;
				ry=ty*1.8710937;
				np=np+1;
				nde=nde+1;
			       _settextposition(23,71);
				printf("   ");
			       _settextposition(23,77);
				printf("   ");
			       _settextposition(23,71);
				printf("%X",dx);
			       _settextposition(23,77);
				printf("%X",dy);
 
				_settextposition(22,71);
				printf("%d",nde);
				_setcolor(c);
				_setpixel(rx,ry);
			    }
		      }
		    xy=fgetc(fichier);
		   _settextposition(6,71);
		    printf("%d",np);
		 }
	    if(feof(fichier));
	  }
  }
fclose(fichier);
}

Merci d'avance. Serge

19/12/2018, 10h17
Médinoc
Bonjour,
1. Quitte à passer à du C++, tu devrais prendre un EDI plus récent que Dev-C++ (Code::Blocks par exemple).
2. Ah, les graphismes sur terminal... Il me semble que le plus portable pour ça, c'est la bibliothèque pdcurses (l'autre solution étant d'abandonner le TUI pour passer à un terminal "bête" ou à une vraie application fenêtrée).
3. Ton code possède un nombre dérangeant de variables globales, variables déclarées mais non-référencées, variables au nom non-informatif, usages de fonctions non-sécurisées (comme gets()), nombres magiques (pourquoi 1.8710937?), usages incorrects de feof()...Le nombre de commentaires dérange aussi, mais dans l'autre sens.
20/12/2018, 06h53
Orion2

Code::Blocks

Bonjour,
Tous d’abord un grand merci pour la réponse, je sais qu’il y a un paquet de variable inutile car a la base le programme est plus conséquent et j’ai récupéré la partie « lecture de fichier » qui fonctionne très bien sous dos.
Du fait hier j’ai essayer le Code::Blocks avec le graphics.h a rajouter, mais bon, même une simple fenêtre c’est tout un art de programmation surtout d’un Windows a l’autre.
Donc actuellement je travaille avec Win 7 pro intégrale, dans l’espoir de savoir tiré quelque chose de la ?, ce n’est pas gagné !, je me posais la question serai ce pas plus facile sous VB, qui je pense est plus adéquat pour se genre de programme.
Bien à toi.
20/12/2018, 11h06
Médinoc

Aurais-tu un échantillon de fichier à traiter pour qu'on voie un peu mieux à quoi la sortie est censée ressembler?

Citation:

Donc actuellement je travaille avec Win 7 pro intégrale, dans l’espoir de savoir tiré quelque chose de la ?, ce n’est pas gagné !, je me posais la question serai ce pas plus facile sous VB, qui je pense est plus adéquat pour se genre de programme.

De préférence VB.Net ou C#, je conseillerais: ça permet un affichage graphique assez facilement.

Je pense que le plus gros problème de ce code, c'est qu'il est pratiquement impossible à porter sur une plate-forme qui n'a pas les mêmes capacités d'affichage facile (positionnement du texte au pixel près, etc.) parce que la lecture du fichier est complètement entrelacée avec l'affichage. Il n'y a pas de lecture vers une représentation mémoire indépendante du reste.

Puis il y a les autres problèmes, comme l'absence totale de commentaires, les noms de variable à une ou deux lettres, qui font qu'on ne peut même pas comprendre ce que le code est censé faire, surtout sans échantillon de fichier.

L'usage incorrect de feof() complique encore les choses, parce qu'on a facilement peur que le code marche "par accident" et que le corriger casse en fait son fonctionnement...

Enfin, voici le code ré-indenté, avec des "stubs" des fonctions graphiques pour que ça compile sous Windows (j'ai utilisé Visual Studio, mais ça devrait aussi pouvoir compiler sous Code::Blocks). J'ai ajouté des commentaires sur les accolades fermantes pour qu'on voie plus facilement à quoi ça fait référence.
J'ai aussi changé les short en int parceque sinon j'avais des warnings de conversion presque partout, à cause des promotions d'entiers sur les opérations mathématiques. Mais si ça a une influence sur le déroulement du code, ça veut dire qu'il était encore pire que je pensais.

Code:

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#include <stdio.h>
#include <windows.h>
 
void _settextposition(int x, int y) { printf("_settextposition(%d, %d)\n", x, y); }
void _outtext(char const *s) { printf("_outtext(%s)\n", s); }
void _setcliprgn(int a, int b, int c, int d) { printf("_setcliprgn(%d, %d, %d, %d)\n", a, b, c, d); }
void _clearscreen(char const *s) { printf("_clearscreen(%s)\n", s); }
void _settextcolor(int c) { printf("_settextcolor(%s)\n", c); SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), (WORD)c); }
void _setpixel(int x, int y) { printf("_setpixel(%d, %d)\n", x, y); }
void _setcolor(int c) {  printf("_setcolor(%s)\n", c);  }
 
#define _GVIEWPORT "_GVIEWPORT"
 
void fload()
{
	int a=0x11,b=0x10,c=15,cpt,sw=0,dx,dy,tes=0,test=0,nd=0,nde=0;
	fpos_t  posi;
	int x,xx,rx,y,yy,ty,xy,ry,np,ex,ey;
	FILE *fichier;
	char ligne[FILENAME_MAX];
	np=0;
	_settextposition(4,71);
	_outtext("        ");
	_settextcolor(15);
	_settextposition(27,04);
 
	_outtext("8 LETTRES MAX.");
	_settextposition(28,04);
	_outtext("Entrez le nom du fichier :");
	_settextcolor(11);
	fgets(ligne, FILENAME_MAX, stdin);
	_setcliprgn(1,1,478,478);
	_clearscreen(_GVIEWPORT);
	_settextposition(4,71);
	printf("%s",ligne);
 
	if((fichier=fopen(ligne,"r"))==NULL)
	{
		_settextposition(28,10);
		_outtext("Impossible d'ouvrir le fichier");
		return;
	}
	rewind(fichier);
 
	while(!feof(fichier))
	{
		xy=fgetc(fichier);
		for ( ; sw!=1 ; xy=fgetc(fichier) )
			/****************************************************************************
                        RECHERCHE & CALCUL DE LA MATRIX
                        ****************************************************************************/
			if(xy==a)sw=1;
		if(xy==a){}
		else
		{
			for (cpt=1 ; !feof(fichier) && xy!=a ; cpt++)
			{
				if (cpt==1)
				{
					x=xy;
					if(x<127)xx=x+128;
					else xx=x-128;
				}
				else if (cpt==2)
				{
					y=xy;
					if(y<127)yy=y+128;
					else yy=y-128;
					ty=255-yy;
					rx=xx*1.8710937;
					ry=ty*1.8710937;
					np=np+1;
					nd=nd+1;
					_settextposition(21,71);
					printf("%X",x);
					_settextposition(21,77);
					printf("%X",y);
					_settextposition(20,71);
					printf("%d",nd);
					_setcolor(c);
					_setpixel(rx,ry);
				}
				else if (cpt>=3)
				{
					if(xy==0x10)
					{
						xy=fgetc(fichier);
						if(xy==0x80)
						{
							_settextposition(8,71);
							printf("OPEN ");
							c=15;
							xy=fgetc(fichier);
						}
						if(xy==0x00)
						{
							_settextposition(8,71);
							printf("CLOSE");
							c=10;
							xy=fgetc(fichier);
						}
					}
					if(xy==00) {}
					else
					{
						dx=xy/b;
						dy=xy%b;
						ex=dx-8;
						ey=dy-8;
						xx=xx+ex;
						yy=yy+ey;
						ty=255-yy;
						rx=xx*1.8710937;
						ry=ty*1.8710937;
						np=np+1;
						nde=nde+1;
						_settextposition(23,71);
						printf("   ");
						_settextposition(23,77);
						printf("   ");
						_settextposition(23,71);
						printf("%X",dx);
						_settextposition(23,77);
						printf("%X",dy);
 
						_settextposition(22,71);
						printf("%d",nde);
						_setcolor(c);
						_setpixel(rx,ry);
					}
				} //successive ifs on cpt
				xy=fgetc(fichier);
				_settextposition(6,71);
				printf("%d",np);
			} //inner for
			if(feof(fichier)); //this does nothing!
		} //else of the big if
	} //outer while
	fclose(fichier);
}

20/12/2018, 17h39
Orion2

1 pièce(s) jointe(s)

Médinoc déjà un grand merci de te penchez sur le cas

Bonjour,
Déjà un grand merci de te penchez sur le cas de lecture du fichier touts se que je sais t’envoie ses le PDF en pièce jointe avec je pense un peux toutes les explications, le fichier source est déjà dans la discutions.
Dans le PDF tu trouveras, les explications, l’écran de sortie et le fichier Hexa qu’il a lu pour afficher sa a l’écran.
De mon coter j’essaye sur Code::Blocks j’arrive a recréé un peux le concept mais je n’arrive pas a afficher les variable : type les nombres de points par exemple, ou entré le nom de fichier il est vrai que depuis 93 pas mal de chose on changer.
Du genre au lieu de printf(%d,pts) ; maintenant c’est outtext(posx,posy,var) ;
Si au cas où je peux toujours t’envoie mon mail perso comme cela des que j’ai le tient je serais t’envoie un fichier Hexa que je ne sais pas mettre en pièce joindre.
Bon je continue avec acharnement pour trouver l’astuce des syntaxes dans graphics.h.

Encore Merci.
Serge
21/12/2018, 06h39
Orion2

error

Bonjour,
Je suis un peux dégouter, hier toutes l’après midi pas de problème avec Code ::Blocks j’ai oser éteindre mon pc le soir quand je l’ai rallumé avec le petit soft que je testais voila la good news « Error » :

Citation:

||=== Build: Debug in digittest (compiler: GNU GCC Compiler) ===|
C:\Program Files\CodeBlocks\MinGW\bin\..\lib\gcc\mingw32\5.1.0\..\..\..\libmingw32.a(main.o):main.c:(.text.startup+0xa7)||undefined reference to `WinMain@16|
||error: ld returned 1 exit status|
||=== Build failed: 2 error(s), 0 warning(s) (0 minute(s), 2 second(s)) ===|

Et avec n’importe quelle source que je teste ???.
je ne suis pas du genre a abandonner mais la ses Windows dépasse l’entendement. J’irais presque a dire vive le Ms Dos.
De plus j’ai du rallumer mon portable avec le bon vieux XP qui est plus stable que toute les versions de Windows qui on suivit, car sur les autres version il ne veux même pas compiler ??.
Si par le plus grand des hasard tu a une idée elle est la bien venue.

Merci.

Serge
21/12/2018, 10h20
Orion2

émulateur c++ sous windows

Bonjour,

Connait tu cette émulateur car si j'ai cela touts est régler.

Voici le lien : https://www.youtube.com/watch?v=kyaznKLsdYA

Merci
Serge
21/12/2018, 13h28
dalfab

Pour ton problème de cette nuit. C'est dû au fait que tu crées un projet Windows graphique alors qu'il faut créer un fichier Windows console dans ton cas. A moins de porter l'ensemble du code sous Windows, ce qui reste une possibilité (il n'y aura plus la fonction main() mais une machinerie basée sur la fonction WinMain() à la place.)

Pour l'émulateur, ça serait la piste de ne pas recompiler le code mais l'utiliser tel quel dans un émulateur. Là attention plus le temps passe moins les émulateurs fonctionneront.

Le code n'est pas bien grand, le comprendre et le réécrire ne devrait être si compliqué.
21/12/2018, 14h23
koala01

Salut,

Avant tout, j'aimerais te poser une question idiote : dois tu absolument garder cette approche dos :question;

L'alternative étant étant donné que tu dois quand même moderniser ton code (autrement, tu n'aurais pas poser de question ici) de partir sur un nouveau projet fonctionnant en mode fenêtré avec une IHM classique, avec menus, zone d'éditions, boutons et autres labels; sans oublier une zone de raytracing (car c'est ce que tu fais, sommes toutes) confortable.

Ce genre d'IHM peut être mise en place en ... 1/2heure avec Qt ou QML, le gros de la difficulté portant sur la zone de raytracing (et dans la récupération des données, bien sur :D) ... ou pas.

Mais le gros avantage de Qt, c'est d'être une bibliothèque graphique tout à fait portable, que tu pourras utiliser pour fournir ton application sous windows, linux ou mac sans aucun problème.

Quant au programme dont tu montre la video, j'aurais tendance à dire qu'il s'agit de turbo C++ : l'EDI que borland a sorti avant même que le C++ ne soit standardisé.

Cet outil n'arrangerait rien à ton problème, car le compilateur associé à cet outil date ... des années 90, et est spécifiquement développé pour les windows de l'époque (je suspecte d'ailleurs que ton projet actuel ait été développé à l'époque avec cet EDI particulier :P )

Par contre, si tu as encore un exécutable qui fonctionne, l'une des solution pourrait être -- tout simplement -- d'installer une machine virtuelle sous windows 95 / 98 sur ton windows 10, et de faire tourner le programme dessus ;)
21/12/2018, 14h34
Orion2

programme sous une autres platforme ?

Bonjour,

Je ne tiens pas spécialement à le faire tourner sous dos mais voila :
J’ai le fichier exécutable qui fonctionne, mais il y a un léger bug dedans c’est pourquoi je voudrais le modifier car j’ai un paquet d’image à importer.
Effectivement ce programme je l’ai fait en 93 avec turbo c++ sous dos.

J’ai la source l’exécutable si il y a moyen de le retranscrire assez facilement sur une autre plateforme pourquoi pas.

Le seul souci je ne connais pas les IHM, QT ou QML, c’est quoi es quoi donc ???:oops:

Bien à toi.

Serge
21/12/2018, 15h41
koala01

1 pièce(s) jointe(s)

Alors, à mon sens, une fois l'interface (graphique) du programme créée, le reste devrait pouvoir se faire assez facilement ;)

Qt (et non QT, qui est autre chose : c'est le sigle de QuickTime, même s'il n'est plus utilisé depuis mathuzalem :P) est un framework qui était à l'origine déstiné à fournir une bibliothèque de création d'IHM (interface homme machine) et qui a évolué au point de fournir un tas de possibilités qui s'écartent finalement de plus en plus de cet objectif d'origine.

C'est un projet développé en C++ pour le C++, opensource (donc tout à fait gratuit à l'utilisation), portable (tu peux compiler ton application pour la faire fonctionner sous windows, linux et mac au besoin) qui dispose d'une très grosse communauté pour t'aider (et qui dispose même de sa propre section sur ce forum), qui supporte les habitudes prises avec les dernières normes du langage (C++1, C++14 et C++17), susceptible d'être utilisé avec la plupart des compilateurs et des EDI (environnement de développement) récents, et qui te permettra -- grâce à son designer -- de créer l'interface graphique en ... 20 cliques à peu près.

Bref, c'est un framework qui présente énormément d'avantages et auquel il n'est pas inutile d'accorder quelques heures d'apprentissage :D

Pour te donner une idée, ce framework m'a permis de créer une IHM ressemblant àPièce jointe 436247
En à peine vingt minutes

Avoue que c'est quand même fort proche de ton programme originel non :question: :D

QML est un langage (déclaratif, si cela présente un intérêt) développé par Qt qui permet d'adapter Qt à encore plus de situations.
21/12/2018, 16h08
Orion2

Ouaaaaaa

Sa a l'air génial.

c'est bien vrai mais sa ressemble fort a la plateforme VB ou je me trompe ?

Serge
21/12/2018, 16h30
koala01
Ca ressemble en fait à ce que tu pourrais faire avec n'importe quelle bibliothèque de gestion d'interface graphique...

Tu sais, une interface graphique, ce n'est jamais qu'une représentation des habitudes que les utilisateurs ont prises avec le temps : les boutons et les zones d'éditions sont rectangulaires, les menus sont en haut de la fenêtre, les éléments qui peuvent être "regroupés entre eux" sont entouré d'un rectangle, ...

Toutes les bibliothèques fournissent les même notions (menu, zone d'édition, boutons, label, ... ) pour représenter les mêmes habitudes. Il n'y a donc rien d'étonnant à ce que le résultat de l'une ressemble à s'y méprendre au résultat de l'autre ;) :D

Pour paraphraser Fox Mulder : "la vrai différence est ailleurs", entre autres
- Dans le langage utilisé (VB n'a rien à voir avec C++, qui n'a rien à voir avec java ou avec C)
- la philosophie de la bibliothèque
- dans la manière de manipuler les éléments graphiques
- j'en passe, et sans doute de meilleures
Par contre, je rejoins Médinoc : si nous pouvions au moins avoir un des fichiers que ton application utilise comme exemple (et tant qu'à faire, la partie du code qui comprend l'affichage que tu as gentiment pris soin d'écarter), nous aurions bien plus facile à faire nos propres essais ;)
21/12/2018, 16h54
Orion2

3 pièce(s) jointe(s)

Bonjour,Fichier Hex ou exe ou c

Bonjour,

Se n'est pas que je veux cacher mais sur le forum on n'arrive pas a envoyer des fichiers Hexa ??

Pour le fichier Hexa spi1_1 celui dispo sur Gihtub vu que je suis déjà membre depuis un bout de temps.

Serge

Heu merci Koala pour le conseille.
21/12/2018, 17h51
koala01

Vire moi en vitesse cette adresse mail que je ne saurais voir!

Ce n'est pas parce que je refuse de prendre contact par mail avec toi, c'est surtout pour t'éviter d'être envahi par les spam ;)

Sinon, pourquoi ne créerais tu pas un répertoire git (chez framagit ou github) pour ton projet, sur lequel tu pourrais mettre les fichiers binaires :question:

Cela te permettait, outre un partage aisé des fichiers, de garder l'historique des modifications, et ca, c'est un must to have à l'heure actuelle ;)
21/12/2018, 18h07
Orion2

Fichier Hexa

Voila,

pour downloader le fichier sur github : recherche Fichier-Spir all github. :D

Merci à vous.

Serge
21/12/2018, 18h58
koala01

Pour la cause, je m'attendais à recevoir un lien vers le répertoire git qui m'aurait permis de trouver un des fichiers d'exemple, car, la recherche que tu me propose m'envoie ==>ICI<==.
21/12/2018, 19h20
Orion2

Fichier-Spir

Oups :oops: il faut écrire Fichier-spir ou le lien https://github.com/Orion1070/Fichier-Spir.
22/12/2018, 07h53
Orion2

Qt

Bonjour,

J'ai télécharger Qt je doit dire assez chaud pour manier directement quand même ?

J'essaye sa a l'ai pas mal du tout mais c'est tout un nouveaux concept a gérer.

A tester.

Serge

Ah oui, il vaudrait mieux, pour bien faire, que tu prenne quelque jours pour t'habituer un tout petit peu :D

Par contre, j'ai une mauvaise nouvelle pour toi:

Je (???) crois (???) avoir compris aussi bien ta logique que l'usage auquel tu destinais les différentes variables, mais, si c'est le cas, ton programme présentait un sérieux problème d'échelle, car les deltas (ou, du moins, ce que tu croyais être les delta) ne correspondait pas à la position calculée.

Je présumes que l'affichage allait trop vite et qu'il était trop condensé pour que tu puisse le remarquer, mais j'en suis presque à douter que le résultat que tu obtenais avec ton laser n'ait réellement correspondu à ce que l'affichage te montrais :P

Cela semble assez évident pour moi, car, n'étant pas sous windows (et ne disposant pas des fonction settextposition, setpixel et autres) , mais voulant me faire une idée de ce que donnait ton affichage, je me suis arrangé pour faire apparaitre les informations sous "compréhensible".

Mais, quand tu vois qu'un delta est sensé faire 9 sur l'axe des X et 4 sur l'axe des Y et que cela fait passer la position de 132 à 134 (sur l'axe des X) et de 202 à 209 (sur l'axe des Y), y a de quoi se poser des questions :P

Pour que tu puisse te faire une idée du problème (je te dirai comment le résoudre si tu le souhaite), voici le code que j'ai utilisé pour m'en rendre compte:
Code:

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 102 #include <cstdio> #include <iostream> #include <string> #include <cstring> enum State{ OPEN = 15, CLOSE = 10 }; void fload(); int main(){ fload(); } void fload() { int a=0x11,b=0x10,c=15,cpt,sw=0,dx,dy,tes=0,test=0; fpos_t posi; short x,xx,rx,y,yy,ty,xy,ry,np,ex,ey; std::string filename; std::cin>>filename; FILE *fichier; if((fichier=fopen(filename.data(),"r"))==NULL) { printf("Impossible d'ouvrir le fichier %s", filename.data()); return; } while(!feof(fichier)) { xy=fgetc(fichier); for ( ; sw!=1 ; xy=fgetc(fichier) ) if(xy==a)sw=1; printf("Got %X ",xy); if(xy==a){} else { for (cpt=1 ; !feof(fichier) && xy!=a ; cpt++) { if (cpt==1) { x=xy; if(x<127)xx=x+128; else xx=x-128; } else if (cpt==2) { y=xy; if(y<127)yy=y+128; else yy=y-128; ty=255-yy; rx=xx*1.8710937; ry=ty*1.8710937; np=np+1; tes=tes+1; printf("NBxy:%d x:%x, y:%X ",tes, x, y); printf("status:%d position x:%d, y:%d\n",c,rx,ry); } else if (cpt>=3) { if(xy==0x10) { xy=fgetc(fichier); if(xy==0x80) { printf("\nOPEN\n "); c=15; xy=fgetc(fichier); printf("Got %X ",xy); } if(xy==0x00) { printf("\nCLOSE\n"); c=10; printf("Got %X ",xy); } } if(xy==00) {} else { dx=xy/b; dy=xy%b; ex=dx-8; ey=dy-8; xx=xx+ex; yy=yy+ey; ty=255-yy; rx=xx*1.8710937; ry=ty*1.8710937; np=np+1; test=test+1; printf("NbDelta:%d, ",test); printf("x:%d, y:%d, ",dx,dy); printf("status:%d position x:%d, y:%d\n",c,rx,ry); } } xy=fgetc(fichier); printf("Got %X ",xy); printf("PointsNb:%d\n",np); } } } fclose(fichier); }

22/12/2018, 14h05
Orion2

Le soucis

Bonjour,

Ou aaaaa. Va tester touts sa, juste sur quel plateforme tu la éditer ? puis je lancer avec Code ::Blocks ? :weird:

Bien le système fonctionnait bien et tu pouvais même régler la vitesse de scanne de l’image.
Quand au variable il y en a de trop car j’ai divisé la source de digitalisation en plusieurs parties et bien évidement je n’ai pas supprimé les variables de trop. Pff petit coup de fainéantise a l’époque.

Que je m’explique !! Comme dit plus haut j’avais +/- protégé mon système en fait la carte D/A les data était inverser donc D0 sortie Bus du Cpu un Méga Z80 correspondait a D8 de la carte D/A ainsi de suite :

Cpu D/A
D8  D0
D7  D1
D6  D2

Etc…

Je dois dire, que personne avait trouvé l’astuce et ses pour cela que la matrice Hexa de {l’image} est en 4 partie si on veut. 8O

Mais je te rassure tout de suite le programme de digitalisation fonctionnait très bien pour l’époque et le système de projection Laser était un des meilleur coter et par ailleurs « Laser Media USA » m’en avait commandé plusieurs. Avec des shows programmer sur EPROM.

Voila pour la petite histoire. :P

Grand merci a toi, car je dois avouer, que je pataugeais car cela fait longtemps que je n’ai plus programmé sous os Windows, sauf Arduino ou la j’arrive même a lire les images sur un Nextion 7’’ quoi que sa ne m’arrange pas car je devrais les coller en .jpg ou format du genre.
Je te tiens au courant de l’évolution de la chose.

Je l'ai testé sous debian, avec clang++, mais, a priori, il devrait fonctioner sous n'importe quel système, avec n'importe quel compilateur, vu qu'il n'utilise rien que des trucs tout à fait portables (je me suis contenter de retirer ce qui était trop spécifique à windows, en fait ;) )

cependant je peux parfaitement comprendre que tu n'ai pas vraiment remarqué le problème auquel je fait allusion vu que le problème ne se remarque que si l'on y fait vraiment attention.

Et je ne dis pas que le programme ne fonctionnait pas, je dis :

que je suis surpris que le laser ait tracé une image ressemblante, si ce sont les informations affichées qui permettaient de le piloter, bien qu'elle n'ait pu être "qu'un peu déformée" parce que
les informations affichées ne me semblent pas cohérentes

Pour t'en convaincre, voici les premières sorties que j'obtiens avec le fichier binaire que tu as mis sur github:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 Got C7 PointsNb:0 Got 13 Start at x:c7, y:13 status:15 position x:132, y:202 PointsNb:1 Got 88 NbDelta:1, x:8, y:8, status:15 position x:132, y:202 PointsNb:2 Got 88 NbDelta:2, x:8, y:8, status:15 position x:132, y:202 PointsNb:3 Got 88 NbDelta:3, x:8, y:8, status:15 position x:132, y:202 PointsNb:4 Got 88 NbDelta:4, x:8, y:8, status:15 position x:132, y:202 PointsNb:5 Got 88 NbDelta:5, x:8, y:8, status:15 position x:132, y:202 PointsNb:6 Got 88 NbDelta:6, x:8, y:8, status:15 position x:132, y:202 PointsNb:7 Got 94 NbDelta:7, x:9, y:4, status:15 position x:134, y:209 PointsNb:8 Got 93 NbDelta:8, x:9, y:3, status:15 position x:136, y:218 PointsNb:9 Got 95 NbDelta:9, x:9, y:5, status:15 position x:138, y:224 PointsNb:10 Got 10 OPEN Got B3 NbDelta:10, x:11, y:3, status:15 position x:144, y:233 PointsNb:11 Got C5 NbDelta:11, x:12, y:5, status:15 position x:151, y:239 PointsNb:12 Got C5 NbDelta:12, x:12, y:5, status:15 position x:159, y:245 PointsNb:13 Got A5 NbDelta:13, x:10, y:5, status:15 position x:162, y:250 PointsNb:14 Got A3 NbDelta:14, x:10, y:3, status:15 position x:166, y:260 PointsNb:15 Got A3 NbDelta:15, x:10, y:3, status:15 position x:170, y:269 PointsNb:16 Got 94 NbDelta:16, x:9, y:4, status:15 position x:172, y:276 PointsNb:17 Got 92 NbDelta:17, x:9, y:2, status:15 position x:174, y:288 PointsNb:18 <snip>
avec:

Got = valeur extraite du fichier (non affiché à l'origine)
Start at position de départs (valeur d'origine) x = premiere valeur , y deuxième valeur (positions 21,71 et 21,77)
status = couleur (variable c) : 15 open, 10 close (setcolor)
position x= rx y = ry (positions 23,71 et 23 77)
PointsNB = nb (position 6,71)

( En dressant cette liste, je me rend compte que je n'ai pas fait affiché la variable nde (nombre d'essais :question:) en position 22,71 :P)
( Si cela peut t'aider à savoir où l'information se trouvaiit dans ton programme ... ;) )

Si j'ai bien interprété le résultat obtenu (ce qui reste encore à prouver :P) , le deltat (x et y ) d'une position (d'une ligne particulière) devrait correspondre respectivement à la différence de coordonnées (x et y) par rapport à la ligne précédante, du moins pour Got != (0x)88, et en sachant que - == + et + == - pour les positions (x ou y) comprises entre 127 et 255.

Or, si tu compare, par exemple, les valeurs correspondant aux lignes affichant respectivement PointNb:8 et PointNb:9, tu remarque que la position de départ est à x = 134 et y = 209, et que la position d'arrivée est en x = 136 et y = 218, ce qui correspond à une différence de 2 en x et de 9 en y pour un delta affiché en x de 9 et en y de 3.

Tu vois l'inchoérence :question:

Le gros problème, c'est que toutes les paires de lignes que tu peux envisager d'utiliser présentent ces "distorsions" entre le delta affiché et la différence calculée :P

Et comme je présume -- au risque de partir dans les supputations -- que tu utilisait les valeurs de delta pour piloter ton scanner alors que les positions x et y utilisées que pour l'affichage au niveau du programme, j'en conclus que l'image projetée par le laser ne correspondait "pas tout à fait", qu'elle devait sans doute être "légèrement déformée" par rapport celle qui apparaissait sur ton écran :P

22/12/2018, 19h42
Orion2

1 pièce(s) jointe(s)

Laser

Bonsoir,

J'explique, attention c'est coordonnées ne sont pas afficher avec le laser se n'est rien que pour la lecture sur écran :

Got = valeur extraite du fichier (non affiché à l'origine)
Start at position de départs (valeur d'origine) x = première valeur , y deuxième valeur (positions 21,71 et 21,77)
status = couleur (variable c) : 15 open, 10 close (setcolor)
position x= rx y = ry (positions 23,71 et 23 77)
PointsNB = nb (position 6,71)

Je ne sait pas si tu a lu la pièce jointe dans le forum précédent, je la remet sur se message tu verrat le fichier PDF est relativement explicite tu à l'écran affichable et se qu'il affiche avec l'image spir1.

Bien à toi.
Serge
22/12/2018, 21h49
koala01
Citation:

explique, attention c'est coordonnées ne sont pas afficher avec le laser se n'est rien que pour la lecture sur écran

Ca, je l'ai bien compris, et c'est justement ce qui m'ennuie : que les coordonnées affichées à l'écran puisse -- d'une manière ou d'une autre -- être "faussées" par rapport aux coordonnées "réelles" du laser; par rapport à la position à laquelle il se trouve actuellement (ou vers laquelle il est occupé à se déplacer entre deux étapes)

Je vais essayer de te faire compendre mon soucis autrement...

Si tu reprend le code d'origine, tu verras les instructions
Code:

1 2 3 _setcolor(c); _setpixel(rx,ry);
- aux lignes 150 et 151 et
- aux lignes 198 et 199
A moins que je ne manque vraiment de sommeil (ce qui pourrait très bien être le cas), ces (deux fois) deux lignes définissent la couleur d'un pixel et le font afficher dans la partie gauche de ton écran.

Jusque là, je crois que nous sommes d'accord, et je n'ai pas de problème "particulier".

Sauf que, à mon sens, l'affichage de ce pixel correspond à une situation "physique réelle" qui n'est autre que ... la position vers laquelle le laser pointe (ou pointera lorsqu'il aura terminé son déplacement).

Ce qui m'inquiète, c'est quand on commence à rajouter la notion de delta dans l'histoire. Parce que, encore une fois, il y a la partie "visuelle" ( ce que l'on affiche à droite de l'écran) et la partie "physique" de l'histoire, qui correspond, selon moi, au déplacement que le laser doit effectuer pour rejoindre pour rejoindre sa "position suivante".

J'ai bien compris que tu magouille avec les delta, que la valeur affichée du delta ne correspond pas au déplacement qui est réellement effectué. Le problème, c'est que ta magouille n'est pas assez précise :P

Parce que, sur le même axe (l'axe des Y), on trouve un delta égal à 12 qui occasionne, selon les circonstances, des différence de position sur l'axe parfois de 8, parfois de 7, et le tout alors que l'on reste dans le même quadrant!

Et pour certains de tes deltas, il me semble même avoir eu l'occasion de repérer jusqu'à au moins trois valeurs potentielles :P

Moi, ce qui me chagrine au final dans l'histoire, ce n'est pas que tu aies essayé de protéger ton travail, parce que cela, je le comprend très bien! (*)

C'est surtout que les informations que tu affiches ne correspondent pas à la réalité "physique" du moment auquel elles sont sensées correspondre, et surtout que certaines informations affichées correspondent non pas à la réalité du moment mais ... au résultat de tes magouilles à l'intérieur du fichier.

(*) Note cependant qu'il ne m'a fallu que moins de 24 heures pour comprendre chacune de tes magouilles. Tu me diras sans doute que j'avais facile, vu que j'avais un fichier d'exemple et le code devant les yeux.

Mais, comme ton affichage couplait allègrement le résultat de tes magouilles avec des valeurs réelles (as tu remarqué que chaque ligne affichée par mon code ne correspond jamais qu'à une seule exécution de la boucle de ta fonction, la seule information que j'ai personnellement rajoutée, c'est celle qui correspond au Got :question:) n'importe qui avec un peu de patience, une feuille, un crayon et un éditeur hexadécimal aurait pu retrouver chacune des astuces que tu as mise en place, ce qui rend tes bonnes idées totalement inutiles et futiles :P

Enfin, le code que tu nous a montré sous entend que chaque "prestation" du laser nécessitait de lire (ou de relire si tu voulait relancer la même prestation) le fichier adéquat.

C'est peut-être un peu dommage, parce que les accès au disque dur s'avèrent particulièrement lents :P
22/12/2018, 22h09
Orion2

Laser

Bonsoir,
En faite très simple a comprendre, on va dire x, y sont au coin supérieur gauche, puis le point suivant coin inférieur droit, la persistance rétinienne fait que tu vois qu’une ligne, évidement le déplacement entre les deux points doivent être relativement rapide, quoi que avec 8 aller retour seconde sa le fait très bien.
Quand a la lecture des fichiers il n’y a pavait pas de HDD touts était sur eprom donc accès directe.
J’espère que j’ai éclairé les bases du système otique laser, avec deux scanner x et y et le troisième sert pour le blancking « couper des points de digitalisation que l’on ne veut pas voir » repris dans le fichier par l’instruction 88 en Hexa.
Si tu veux de la documentation sur le principe optique, sa me connait j’ai conçus 3 différentes tête optique qui on eu leur heures de gloires.
Bien à toi
Serge.
23/12/2018, 01h45
koala01

Citation:

Envoyé par Orion2

Bonsoir,

Quand a la lecture des fichiers il n’y a pavait pas de HDD touts était sur eprom donc accès directe.
J’espère que j’ai éclairé les bases du système otique laser, avec deux scanner x et y et le troisième sert pour le blancking « couper des points de digitalisation que l’on ne veut pas voir » repris dans le fichier par l’instruction 88 en Hexa.
Si tu veux de la documentation sur le principe optique, sa me connait j’ai conçus 3 différentes tête optique qui on eu leur heures de gloires.
Bien à toi
Serge.

Ok!!!

Je viens de percuter sur la raison de notre incompréhension...

N'étant vraiment pas familier du travail avec les eprom, ce n'est vraiment pas le premier support auquel je pense quand il est question de récupérer des données :P

Du coup, j'envisageais naturellement et assez "naïvement" un accès à des support beaucoup plus lents (disquettes ou disque durs comme on en trouvais sur les 3x86/4x86 et autres dinosaures), en devant récupérer les données du fichier pour les transmettre (par port COM, pour rester dans l'aire du temps) au laser qui aurait en suit dû s'arranger respecter les instructions

Evidemment, nous étions sur deux planètes totalement différentes sur ce coup :D

Citation:

En faite très simple a comprendre, on va dire x, y sont au coin supérieur gauche, puis le point suivant coin inférieur droit, la persistance rétinienne fait que tu vois qu’une ligne, évidement le déplacement entre les deux points doivent être relativement rapide, quoi que avec 8 aller retour seconde sa le fait très bien.

Disons que j'en sais assez pour l'instant pour savoir que c'est un phénomène qui existe et qui peut durer jusqu'à pres de 0.04 secondes (les anciens projecteurs, ceux qui claquaient dans tous les sens étaient bien en 25 images /seconds, non :question: :D ), mais, si tu as des documents sympa (et pas trop scientifiques :P) qui en parlent, je suis toujours d'accord pour améliorer mes connaissances :P
23/12/2018, 14h12
Orion2

Le système solaire n’est pas aussi vaste qu’on le prétend

Bonjour,

J’imagine que tu a déjà vu un show laser ?? Maintenant touts les systèmes travaille en vectorielle d’où leur rapidité a l’encontre de la qualité. :?

Du fait je dois dire que mon système était « un peux lent » mais la qualité graphique était la, surtout pour la projection d’image. 8O

C’est vrai que pour économiser le Z80 je travaillais sur un terminal (cherche pas on en voit plus) et une carte D/A s’occupait de touts le boulot, quand aux images elles étaient stocké sur EPROM système simple mais efficace. Maintenant j’ai de la doc sur touts c’est suivant se que tu veux savoir. :D

Si tu veux des infos sur la harpe laser de jarre tu peux demander, car ses bibi qui a conçut les système 8 faisceaux = 8 notes + 1 pour changer d'octave très bête mais sa a fait sont succès. 8O

Système optique, laser en lui-même etc…

Bien à toi

Serge
30/12/2018, 12h25
Orion2

1 pièce(s) jointe(s)

Encore une question

Bonjour et bonne fêtes quand même,

Peut on avoir un résultat comme la pièce jointe avec le c++ ou il faudrait se pencher plus coter VB ?
Quand au prog me reste un souci, comme dans certain fichiers j’ai LA valeur en Hexa 1A = eof,
peut on éviter que le prog arrête de lire après lecture de cette info et puisse la traiter comme une instruction banale ?

Bien à toi.

Serge
31/12/2018, 03h43
dalfab

Il n'y a aucune raison faisant que le C++ soit moins apte à faire quelque que le VB. Cela peut être plus facile dans un langage que dans un autre. Je pense que la pièce jointe, le C++ devrait être plus adapté.
Un caractère EOF n'a aucune raison d'être dans un fichier texte, sauf en dernier caractère. Si on souhaite lire un fichier binaire, il faut l'ouvrir avec fopen(nom,"rb"), on lira dans ce fichier des octets et toutes les valeurs sont permises y compris le NUL='\0' et le EOF='\x1A'.
31/12/2018, 11h16
Orion2

La question

Bonjour,

Bien comme dans la pièce jointe il y a une fenêtre "graphique" ou l'on peut disposer des pixels ou on veux, sorry mais en c++ avec Windows c'est pas trop évident en tout cas pour moi.

Si tu voit la date du programme je l'ai effectivement fait mais en 1993 et sou Msdos donc très facile, mais maintenant avec se Windows en font pas trop évident.

Si quelqu'un peux m'aiguiller sur une bonne vois je demande pas mieux, donc je travaille avec code::Blocks qui apparemment le fait très bien, mais bon fenêtre et le reste la je coince ???

Bien à vous.

Serge
07/01/2019, 16h59
bacelar

Ce que tu cherches à faire au niveau graphique est "facilement" faisable avec n'importe quel langage disposant d'au moins une librairie graphique.
Ton code doit utiliser la librairie graphique "VCL" de Borland, si mes souvenirs sont bons.
"VCL" doit être dépassé mais doit encore exister dans les versions "récentes" des outils Borland.
Cela serait peut-être plus facile à reprendre mais c'est aussi s'enfermer dans des outils propriétaires pas donnés et pas des plus efficaces en terme de développement.

On peut faire des IHM sous Windows juste avec l'API Native de Microsoft, Win32, mais je vous le déconseille vivement car le niveau de la partie graphique de cette API est très très bas (faire beaucoup de code pour pas grand-chose au final).
Je vous conseille donc, même si vous voulez rester en C++ sous Windows d'utiliser une librairie graphique, comme MFC (directement intégrée à Visual C++) ou Qt.

Attention, Code::Blocks, est un IDE, et pas un compilateur ou une librairie graphique.
Cet IDE peut être configuré pour utiliser plusieurs compilateurs différents.
Mais il faut configurer chaque projet Code::Blocks pour utiliser un compilateur spécifique ET aussi configurer le projet pour utiliser une librairie graphique compatible avec le compilateur choisi (voir installé la bibliothèque graphique pour ce compilateur).

Vos besoins vous permettent de choisir assez librement une solution car vos contraintes et exigences semblent faibles.

Le plus simple, pour du C++, c'est de lire un tutoriel sur Qt ou MFC dans l'IDE de votre choix pour la création d'une application graphique "de base".
Une fois le ou les tutoriels compulsés, vous devriez assez facilement faire votre IHM car "VCL" était bien plus galère à utiliser que les librairies graphiques actuelles (si vous utilisez efficacement l'outillage qu'elles proposent).