Discussion :

[skizofire]

voilà le programme complet :

Code C :

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
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
#include "socketcan_peak.h"
 
 
struct ifreq ifr;
 
 
/**************************************
*
* ssyCANSendMsg
*
*/
int ssyCANSendMsg(int s,char *sMsg, int nMsgSize, char idsend) 
{
TPCANMsg frame;
int ret,i;
//printf("j'envoie un message");
 
frame.ID = idsend;				//identifiant du message
frame.LEN = nMsgSize;			//taille du message
strcpy(frame.DATA, sMsg);		//copy sMsg dans frame.data
 
/*for(i=0; i < sizeof(frame.data);i++)
{
printf("sMsg=%X",sMsg[i]);
}
printf("\n");*/
ret = CAN_Write(s, &frame);		//ecrit 
	if( ret == -1 ) {
	perror("write");
			}
printf("Envoie sMsg=%x %x ident= %x\n",sMsg[0],sMsg[1],idsend);	
printf("Envoie frame.DATA=%x %x ident= %x\n",frame.DATA[0],frame.DATA[1],idsend);			
return SSY_DEF_SOCK_OK;
}
 
/**************************************
*
* ssyCANReceiveMsg
*
*/
int ssyCANReceiveMsg (int s, char *sMsg, int nMsgSize,int *ident)
{
int ret,i;
TPCANMsg frame;
/*
for(i=0; i < sizeof(frame.data);i++)
{
frame.data[i]=0;
}*/
 
//printf("je suis dans receive message\n");
 
ret = CAN_Read(s, &frame);	//lecture du socket
	if( ret == -1 ) {
	perror("write");
			}
 
 
memcpy(sMsg, &frame.DATA,nMsgSize);		//copie de frame.data dans sMsg
*ident=frame.ID;			//copie de l'identifiant du message dans ident
//printf("Reception sMsg=%x %x ident=%x \n",sMsg[0],sMsg[1],&ident);
//printf("je suis dans receive message3\n");
  return SSY_DEF_SOCK_OK;
}
 
/**************************************
*
* ssyCreateInetSocket
*
*/
 
int ssyCreateInetSocket()
{
/*
int family = PF_CAN, type = SOCK_RAW, proto = CAN_RAW, s;
struct sockaddr_can addr;
 
 
	if ((s = socket(family, type, proto)) < 0) {	//création du socket 
		perror("socket");
		return 1;
	}
 
	addr.can_family = family;			//protocol can
	strcpy(ifr.ifr_name, "can0");
	if( ioctl(s, SIOCGIFINDEX, &ifr) ) {
		perror("ioctl");
		return 1;
	}
	addr.can_ifindex = ifr.ifr_ifindex;
 
	if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {	//rattachement du protocol can au socket
		perror("bind");
		return 1;
	}
return (s);*/
}
/**************************************
*
* ssySocketClose
*
*/
int ssySocketClose(int s)
{
 CAN_Close(s);	//ferme le socket s
}
 
/**************************************
*
* ssyCANServerOpen
*
*/
int ssyCANServerOpen(int *s)
{
  const char  *szDevNode = DEFAULT_NODE;
 
  *s = LINUX_CAN_Open(szDevNode, O_RDWR); 		//ouvre le socket	
 
  return 0;
}
 
 
/**************************************
*
* ssyCANClose
*
*/
int ssyCANClose(int s)
{
 
  return(ssySocketClose(s));	//ferme le CAN
}

et comme résultat de compilation :

socketcan_peak.C: In function ‘int ssyCANSendMsg(int, char*, int, char)’:
socketcan_peak.C:21: error: invalid conversion from ‘__u8*’ to ‘char*’
socketcan_peak.C:21: error: initializing argument 1 of ‘char* strcpy(char*, const char*)’
socketcan_peak.C:28: error: invalid conversion from ‘int’ to ‘void*’
socketcan_peak.C:28: error: initializing argument 1 of ‘__u32 CAN_Write(void*, TPCANMsg*)’
socketcan_peak.C: In function ‘int ssyCANReceiveMsg(int, char*, int, int*)’:
socketcan_peak.C:54: error: invalid conversion from ‘int’ to ‘void*’
socketcan_peak.C:54: error: initializing argument 1 of ‘__u32 CAN_Read(void*, TPCANMsg*)’
socketcan_peak.C: In function ‘int ssySocketClose(int)’:
socketcan_peak.C:106: error: invalid conversion from ‘int’ to ‘void*’
socketcan_peak.C:106: error: initializing argument 1 of ‘__u32 CAN_Close(void*)’
socketcan_peak.C: In function ‘int ssyCANServerOpen(int*)’:
socketcan_peak.C:118: error: invalid conversion from ‘void*’ to ‘int’

[Médinoc]

Ben, c'est assez explicite:

• strcpy() demande un char*, mais tu lui passes l'adresse d'un tableau de __u8 (sans doute unsigned char). Tu dois faire un cast explicite (et vérifier que tu ne débordes pas du tableau; je conseille pour cela la méthode vidage+strncat()).
• CAN_Write() demande un void* en premier paramètre, et toi, tu lui passes un int.
• Pareil pour CAN_Read()
• Et pour CAN_Close()
• Et dans ta fonction ssyCANServerOpen(), le résultat de LINUX_CAN_Open() est supposé être un void*, toi tu le forces dans un int.

Je commence à en avoir marre de devoir faire la traduction entre un compilateur et l'utilisateur...

[LittleWhite]

Je commence à en avoir marre de devoir faire la traduction entre un compilateur et l'utilisateur...

surtout que je crois qu'il existe un programme pour cela ( du moins sous linux pour gcc )

[Tusbar]

surtout que je crois qu'il existe un programme pour cela ( du moins sous linux pour gcc )

Un programme pour apprendre à lire ?

[LittleWhite]

Du moins qui simplifie les messages de gcc ... mais c'est peut être dans un de mes rêves :p

[souviron34]

Du moins qui simplifie les messages de gcc ... mais c'est peut être dans un de mes rêves :p

simplifier ???

Le message te dit à quelle ligne et quelle est l'erreur...

Qu'est-ce que tu veux de plus simple ??

[LittleWhite]

Oui c'est vrai , je suis un peu idiot , ou alors c'est que il y a deux ans , je peinais encore beaucoup trop. ...