Discussion :

[matlinuxos]

Bonjour!

Je dois bâtir un code qui calcul une valeur de checksum LRC
jai une chaîne avec des chiffres et je dois les additionnés par groupe de 2:

Code :

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

1
2
 
char commande = "01050500FF00"

donc : 01+05+05+00+FF+00 = 10A

ensuite, je dois conserver les deux dernières valeur soit 0A et le soustraire de 256 (0x100)

donc : 0x100 - 0x0A = 0xF6

Le résultat final de la nouvelle chaine sera ceci : ":01050500FF00F6/r/n"

sa semble plutôt compliqué et mes connaissance en C sont assez rudimentaire.. je crois qu'il faut que j'utilise sscanf( ) mais j'en ai pas la certitude

Quelqu'un peut me donner une piste ?

[Republic]

Salut,

Oui, il est possible de procéder avec sscanf(), ou autrement. Poste un code pour qu'on puisse t'aider.

Cordialement, Republic.

[diogene]

Code :

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

char const * commande = "01050500FF00"

1- Comme tu dois faire des opérations arithmétiques sur les valeurs lues, tu dois utiliser un format de conversion hexadécimal -> nombre soit %x
2- Tes valeurs hexa sont sur deux caractères, il faut limiter chaque conversion à deux caractères : format %2x
3- La première donnée est située en commande, la seconde en commande+2, la troisième en commande+4,...
On va donc faire une boucle sur sscanf() lisant 2 caractères à partir de l'adresse deb. Au départ deb = commande, puis deb est incrémenté de 2 à chaque boucle : deb=deb+2
4- Pour terminer la boucle, on va tester le retour de sscanf : il doit être égal au nombre de conversion réussie par le sscanf() (donc ici 1). A la fin de l'analyse de la chaine, il rendra une valeur différente (EOF).
5- On doit faire la somme mod 256. Si tes char sont bien sur 8 bits, il suffit de sommer dans un unsigned char, le modulo sera fait automatiquement.
6- De même, pour le soustraire de 256, il suffit dans ce cas de prendre son opposé.

Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
unsigned char LRC(const char * commande)
{
  int n;
  unsigned char som;
  const char * deb;
  for(deb = commande, som=0; sscanf(deb, "%2x",&n)==1 ; deb += 2)som += n ;
  return -som;
}
int main(void)
{
 unsigned char  som = LRC("01050500FF00");
 return 0;
}

[matlinuxos]

Mais c'est du tout cuit !!!

Je ne pouvais pas espèrer mieux. Très éléguant comme code! beaucoup plus simple que tout ce que j'ai tenté jusqu'à présent!!


Un gros merci!

[Republic]

@diogene : Alors comme ça on donne du code tout prêt. Très efficace quand on veut apprendre !

[matlinuxos]

@Republic : Ne t'en fait pas... ce n'est une petite partie d'un programme beaucoup plus imposant ! et... bien que je n'ai pas posté de code, ce n'est pas comme si je n'avait pas essayé.. mais j'étais vraiment "dans le champs"...

Pour information mon programme servira à contrôler les automates EATON à partir d'un ordinateur par l'interface RS-232(port série) Ce n'est pas si complèxe mais c'est un bon morceau pour un débutant autodidacte...

[matlinuxos]

Salut à vous,

J'ai quelque peu modifié le code et j'ai un problème... impossible de faire un printf de la var result, l'affichage n'est pas coérant. je crois que le problème est que la due au fait que je dois transférer le résultat en signed char mais je n'en suis pas certain...

quelqu'un peut me donner une piste ??

Merci encore!!

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
#include <stdio.h> // standard input / output functions
#include <string.h> // string function definitions
 
unsigned char send_port(const char * commande){
	char head[] = ":";
	char tail[] = "\r\n";
	char result[80];
	int n;
	unsigned char som;
	const char * deb;
 
	for(deb = commande, som=0; sscanf(deb, "%2x",&n)==1 ; deb += 2)
		som += n ;
 
	sprintf(result,"%s""%s""%x""%s",head,commande,(0x100-som),tail);
	/*
	 * n = write(fd,&result,strlen(result));
	if (n==-1)
		printf("écriture échoué : %d \n",errno);
	else
		printf("écriture réussi !\n %d octets écrit sur le port\n",n);
	*/
 
  printf("%s\n",result);
  return result;
}
int main(void){
	int n;
	char force_y0[20] = "01050500FF00";
//	force_y0[20] = "01050500FF00";
	char result ;
	result = send_port(force_y0);
 
	printf("%x", result);
 
	return 0;
}

[diogene]

La fonction send_port() est fausse et incohérente :

Code :

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

1
2
3
4
5
6
unsigned char send_port(const char * commande){
....
	char result[80];
....
  return result;
}

- La fonction send_port() renvoie l'adresse d'une variable locale (result) ce qui est rigoureusement interdit : la variable locale est détruite en sortie de fonction et l'adresse n'a alors plus aucun sens

- Elle renvoie un char * alors que le prototype de la fonction spécifie un unsigned char qui n'est pas une adresse. Le compilateur a dû hurler de colère !

[matlinuxos]

Premièrement, Désoler pour le dernier code qui n'était pas tout à fait bien construit..

Maintenant le code de génération LRC fonctionne très bien sauf pour un léger détail plus difficile à résoudre :

Le retour de la fonction me donne : f6 mais je dois absolument envoyer F6 (en ascii) pour que sa fonctionne.

J'ai essayer avec toupper( ) mais bient entendu sa ne fonctionne pas parce que le résultat est une valeur hex et non un véritable char. Quelqu'un connait un moyen ?

voici le code :

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
 
unsigned char calc_LRC(const char * commande){
	int n;
	unsigned char som;
	const char * deb;
 
	for(deb = commande, som=0; sscanf(deb, "%2x",&n)==1 ; deb += 2)
		som += n ;
 
	//printf("dans la fonction\n");
	//printf("%s\n",0x100-som);
  return -som;
}
 
void send_port(char * commande,int fd){
	/*constructeur de commande*/
	int n;
	int i;
	char head[] = ":";
	char tail[] = "\r\n";
	char result[80];
 
	unsigned char LRC =  calc_LRC(commande);
	char test;
	test = toupper(LRC);
	printf("valeur de c is %s\n",test);
//	printf("%x",0x100-LRC);
 
	sprintf(result,"%s""%s""%x""%s",head,commande,LRC,tail);
	printf("%s\n",result);
 
	n = write(fd,result,strlen(result));
	if (n==-1)
		printf("écriture échoué : %d \n",errno);
	else
		printf("écriture réussi !\n %d octets écrit sur le port\n",n);
 
	//return 0;
}

[matlinuxos]

oups!!! j'ai allumé....

je devais écrire %X pour que le résultat soit en caps...


désoler du dérangement !!!