Conversion C++ 1990 à Dev C++

**koala01** · 22/12/2018, 11h18

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

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

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

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 :

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
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);
}

**Orion2** · 22/12/2018, 14h05

Bonjour,

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

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.

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.

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.

**koala01** · 22/12/2018, 17h12

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 :

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
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

) en position 22,71

)
( 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

) , 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

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

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

**Orion2** · 22/12/2018, 19h42

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

**koala01** · 22/12/2018, 21h49

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 :

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

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

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

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

) 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

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

**Orion2** · 22/12/2018, 22h09

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.

**koala01** · 23/12/2018, 01h45

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

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

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

), mais, si tu as des documents sympa (et pas trop scientifiques

) qui en parlent, je suis toujours d'accord pour améliorer mes connaissances

**Orion2** · 23/12/2018, 14h12

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.

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.

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.

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

Bien à toi

Serge

**Orion2** · 30/12/2018, 12h25

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

**dalfab** · 31/12/2018, 03h43

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'.

**Orion2** · 31/12/2018, 11h16

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

**bacelar** · 07/01/2019, 16h59

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).

Conversion C++ 1990 à Dev C++

C++

Discussions similaires

Partager

Partager