next topic »

[on:]

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 :

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

[Reply #1 on:]

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

Code:

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

}

[Reply #2 on:]

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

Code:

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

[Reply #3 on:]

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 ?

[Reply #4 on:]

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

[Reply #5 on:]

Merci JF, je comprend mieux les tableaux maintenant

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

[Reply #6 on:]

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

Code:

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