Aide sur Adaptation Programme C sur Arduino

Bonsoir à tous,

Je suis en train d’essayer d’adapter un code en c de Matt Danton, qui permet d’envoyer de simple paquets sur le port série avec un cheksum, afin de contrôler l’une de ses cartes électroniques nommé Pbrain.

J’ai fait plusieurs recherches et adaptation sans succès, et je n’ai pas trouvé de code pour l’arduino s’en rapprochant.

voila son exemple de code :

#include  <stdio.h>
#include  <stdlib.h>
#include  <conio.h>
// ********************************************************************** // DEFINITIONS // **********************************************************************
#define CMD_PIP_HEADER 0x7e 
#define CMD_PIP_ESCAPE 0x7d 
#define CMD_PIP_XOR	0x20
// ********************************************************************** // FUNCTION DEFINITIONS // **********************************************************************
//	SENDS ONE BYTE TO SERIAL PORT 
void	SendByte( char lC ); 
//	OPENS SERIAL PORT 
void	OpenComms( void );
//	CLOSES SERIAL PORT 
void	CloseComms( void ); 
//	SENS PIP PACKET 
void	SendCMDPIPPacket( char *pPtr, char pLen ); 
//	SENDS BYTE CHECKS FOR ILLEGAL CODES
void	SendByteCheckCodes( char lC );

// ********************************************************************** // MAIN CODE // **********************************************************************
void	main( void ) 

{ char lBuffer[10];
//	OPEN COMS DEVICE (User defined communications device) 
OpenComms();
//	SEND HEXENGINE WAKE COMMAND 
lBuffer[0] = '+'; SendCMDPIPPacket( lBuffer, 1 );
//	Delay 10 Seconds 
delay(10000);
//	SEND HEXENGINE SLEEP COMMAND 
lBuffer[0] = '-'; SendCMDPIPPacket( lBuffer, 1);
//	CLOSE COMMS DEVICE 
CloseComms();
//	END 
}

// ********************************************************************** 
// Send Command PIP Packet // 
// Input:
// pPtr = char pointer to data buffer 
// pLen = length of data buffer // 
// Output: none
// **********************************************************************
void	SendCMDPIPPacket( char *pPtr, char pLen ) { 
char lC,lCs,lB;
//	SEND PIP_HEADER 
SendByte( CMD_PIP_HEADER );
//	PACKET COUNT NEEDS ESCAPE CODE CHECKING! 
SendByteCheckCodes( pLen );
//	SETUP CHECK SUM 
lCs = 0;
//	SEND DATA WITH ESCAPE CODES IF NECESSARY. 
//	CALCULATE CHECKSUM WITHOUT ESCAPE CODES. 
for( lC = 0; lC < pLen; lC++ )
{ 
//	lB = NEXT BYTE OF DATA 
lB = *pPtr; 
//	CHECK FOR ILLEGAL CODE & SEND 
SendByteCheckCodes( lB ); 
//	ADD TO CHECK SUM 
lCs += lB; 
//	INCREMENT POINTER 
pPtr++; }
//	CALCULATE CHECKSUM 
lCs = 0xff - lCs;
//	CHECK FOR ILLEGAL CODE + SEND CHECKSUM 
SendByteCheckCodes( lCs );
}
// **************************************************************************** 
// CHECK COMMAND ILLEGAL CODE // 
// INPUT: lC = Byte to be sent
// // OUTPUT: none 
// ****************************************************************************
void	SendByteCheckCodes( char lC ) 
{
//	IF SENDING PIP MODE 0 PACKETS, REMOVE FROM HERE.. 
if( lC == CMD_PIP_HEADER || lC == CMD_PIP_ESCAPE )
{ 
SendByte( CMD_PIP_ESCAPE ); 
SendByte( lC ^ CMD_PIP_XOR );
}
else 
//	TO HERE..
{ 
SendByte(lC ); 
}

J’ai donc essayer de remplacer les commandes avec celle que je maitrise déjà, mais j’ai encore beaucoup de lacunes, si quelqu’un peut me donner une piste…

Voila mon début de code (qui ne donne pas grd chose!)

const int CMD_PIP_ESCAPE = 0x7d;
const int CMD_PIP_HEADER = 0x7e;
const int CMD_PIP_XOR = 0x20;
char lC,lCs,lB;
char *pPtr;
char pLen;

  
void setup() {
  Serial.begin(115200);
}

void	SendByte( char lC ); 
void	SendByteCheckCodes( char lC );

void loop() 
{
  char lBuffer[10];
  Serial.print(lBuffer[0] = '+');
  SendCMDPIPPacket( lBuffer, 1 );
  delay(10000);
  Serial.print(lBuffer[0] = '-'); 
  SendCMDPIPPacket( lBuffer, 1);
}


void SendCMDPIPPacket()
{
  SendByte( CMD_PIP_HEADER );
  SendByteCheckCodes( pLen );
  lCs = 0;

for( lC = 0; lC < pLen; lC++ )
  { 
    lB = *pPtr; 
    SendByteCheckCodes( lB ); 
    lCs += lB; 
    pPtr++; 
  }

lCs = 0xff - lCs;
SendByteCheckCodes( lCs );
}


void	SendByteCheckCodes() 
{ 
if( lC == CMD_PIP_HEADER || lC == CMD_PIP_ESCAPE )
{ 
SendByte( CMD_PIP_ESCAPE ); 
SendByte( lC ^ CMD_PIP_XOR );
}
else
{
  SendByte( lC );
}

}

Je ne sais pas si ça peut t’aider, mais j’avais fait un truc comme ça pour un checksum :

    thisString+="*";
    for(int a=0;a<thisString.length();a++){
      CRC+=thisString[a];
    }
    Serial.print(",*#");
    Serial.print((CRC/20),HEX);
    Serial.println("#");
    CRC=0;

Merci Jean-François.

Je comprend bien le for mais je ne comprend pas pourquoi mettre le "a" entre crochet pr thisString[a];

Quel est l'utilité du + devant thisString et CRC ?

CRC c'est la variable qui totalise le checksum, inString[] est un tableau qui comprend les char qui compose le paquet que je veux envoyer. La boucle for (avec le a) sert à additionner à la variable CRC, la valeur Ascii du char dont la position dans le tableau est inString[a]. += sert à additionner inString avec CRC. Le tout est envoyer à la fin de la chaine et est comparé à la valeur de la chaine reçue... En gros

Merci JF, je comprend mieux les tableaux maintenant :slight_smile:

Concernant le code de Matt danton, qqn est’il capable de m’expliquer comment les données sont envoyé sur le port série ? car il n’y a pas de serial.print mais seulement un openComm et un closeComm, Comment puis je remplacer ces commandes ?

J’ai essayer de bidouiller,

il semblerait qu’il n’y que SendByte et SendByteCheckCodes qui envoi les infos, donc j’ai rajouter dans chacun de leur void un Serial.print(lC , HEX); mais bon j’ai un doute ?

Si qqn a une piste…

J’ai eu cette idée de code, qui ne donne aucune erreur de compil

#define CMDPIPHEADER 0x7e
#define CMDPIPESCAPE 0x7d
#define CMDPIPXOR 0x20

int pointer = 0;

void setup() {
  Serial.begin(115200);
}

void SendByte( char lC ) {
Serial.print(lC , HEX);
}

void SendByteCheckCodes( char lC ) {
Serial.print(lC , HEX);
  if ( lC == CMDPIPHEADER || lC == CMDPIPESCAPE )
  {
    SendByte( CMDPIPESCAPE );
    SendByte( lC ^ CMDPIPXOR );
  }
  else
  {
    SendByte( lC );
  }
}

void SendCMDPIPPacket( char* pPtr, char pLen ) {
  char lCs;
  char lB;
  char lC;
  SendByte( CMDPIPHEADER );
  SendByteCheckCodes( pLen );
  lCs = 0;
  for ( lC = 0; lC < pLen; lC++ )
  {
    lB = *pPtr;
    SendByteCheckCodes( lB );
    lCs += lB;
    pPtr++;
  }
  lCs = 0xff - lCs;
  SendByteCheckCodes( lCs );
}


void loop() {
  char lBuffer[10];
  lBuffer[pointer] = '+';
  SendCMDPIPPacket( lBuffer, 1 );
  delay(10000); // 10secondes
  lBuffer[pointer] = '-';
  SendCMDPIPPacket( lBuffer, 1 );
  }