Convertir tableau char en Hex

Bonjour à tous,

Avec un shield ethernet, je récupère une suite de caractère de la forme char "13A2004062A169" et je voudrais convertir cette chain de caractère en 2 variable en hexa de la forme :

uint32_t msb=0x0013A200;
uint32_t lsb=0x4062A169;

Savez vous, si il existe une fonction pour ça?

Merci par avance

Henry

Peut-être une idée à prendre ici.
Sinon, tu lis les caractères un par un en partant de la droite et tu crées un nombre en multipliant par les puissance des 16 qui vont bien.
Avec ton exemple :
4062A169 donne
9 + 616 + 1256 + 1016^3 + 216^4 + 616^5 + à16^6 + 4*16^7
et tu transformes en hexa ensuite avec la fonction C qui va bien.

Mais il y a peut-être plus simple...

C'est vrai que c'est plus simple :slight_smile:

pepe:
Bonsoir

Pour convertir un nombre hexadécimal stocké dans une chaîne de caractères en un entier long non signé, on peut utiliser la fonction strtoul().

Toutefois, dans le cas présent il est nécessaire de séparer les deux sous-chaînes correspondant aux deux nombres à convertir.

Si la chaîne à traiter (str) se termine par un caractère nul, alors on peut faire par exemple :

  uint32_t msdw, lsdw;

uint8_t len = strlen(str);
  if (len<=8) {
    if (len>0)
      lsdw = strtoul(str, NULL, 16);
    else
      lsdw = 0UL;
    msdw = 0UL;
  } else {
    lsdw = strtoul(&str[len-8], NULL, 16);
    char c = str[len-8];  // *
    str[len-8] = ‘\0’;    // *
    msdw = strtoul(str, NULL, 16);
    str[len-8] = c;      // *
  }




Si la chaîne *str* n'est pas réutilisée après le traitement, alors on peut supprimer les trois lignes marquées par une astérisque ( _// *_ ).

Salut, Merci pour ton retour.

Je viens d’essayer, ça marche plutôt pas mal, sauf pour les hexa de poinds fort.

Quand j’execute le code j’ai ça :

Adresse char : 0013A2004062A169
len : 16
Adresse : FFFFFFFF - 4062A169

Si vous avez une piste?

Merci

Avec substring, dans le cas de plus de 8 caractères, tu peux séparer ta chaîne en deux parties ; les 8 derniers et les autres, et appliquer strotul séparément à des deux nouvelles chaînes

pepe:
Je pense qu’il faudrait commencer par vérifier la partie du code qui affiche ce résultat.

Pour le calcul, chez moi ça marche, y compris pour le mot de poids fort msdw (testé sur Arduino Uno, sous les IDE versions 1.7.11 et 1.8.5).

Salut,

Voici mon code, mais je n’arrive pas trop à comprendre le problème :confused:

merci pour votre aide

// ******************* START librairies ******************* 
#include <SPI.h>
#include <Ethernet2.h>

// ******************* END librairies ******************* 

// ******************* START Ethernet ******************* 
char server[] = "xxx.domaine.fr";    // name address for Google (using DNS)
char DataRead[16];
int i;
// Set the static IP address to use if the DHCP fails to assign
byte mac[] = { 0x90, 0xA2, 0xDA, 0x11, 0x23, 0xA6 }; // Mac address 99-B8-DC-A0-72-F2
IPAddress ip(192, 168, 0, 195);                     // IP Client
IPAddress dnServer(8, 8, 8, 8);                     // the dns server ip
IPAddress gateway(192, 168, 0, 254);                // the router's gateway address:
IPAddress subnet(255, 255, 255, 0);                 // the subnet:
EthernetClient client;                              // Type mode between Server and Client
// ******************* END Ethernet *******************

// ******************* START Setup ******************* 
void setup() {

  Serial.begin(9600);     // Open serial communications and wait for port to open:
  while (!Serial) {;}     // wait for serial port to connect. Needed for Leonardo only

  if (Ethernet.begin(mac) == 0) { // start the Ethernet connection:
    Serial.println("Failed to configure Ethernet using DHCP");    // no point in carrying on, so do nothing forevermore:
    Ethernet.begin(mac, ip);    // try to congifure using IP address instead of DHCP:
  }

}
// ******************* END Setup ******************* 

// ******************* START loop ******************* 
void loop()
{
  
//*************************** START Read g.php Ethernet Data *************************** 
Serial.println("connecting to g.php...");

  if (client.connect(server, 80)) {
    Serial.println("connected");

client.print("GET /g.php");
client.println(" HTTP/1.0");
client.println("HOST: xxx.domaine.fr");
client.println();

Serial.println("Data send ... OK"); 
Serial.println("****************************");
Serial.print("Read Data Ethernet ....");   
  }
  else {
    // kf you didn't get a connection to the server:
    Serial.println("connection failed");
  }

delay(1000);
  while(client.available()) {
      //Serial.print(client.read());
      //char c = client.read();
      //Serial.print(c);
      
    if (client.read() == '\n') {
      if (client.read() == '\r')
      {

        while(client.available()) {
            DataRead[i]=client.read();
            i++;
        }
        DataRead[i]= '\0';
        i=0;
        Serial.println("Data Received.");
        break;
      }
    }

  }

  if (!client.connected()) {
    Serial.println();
    Serial.println("Disconnecting to g.php.");
    client.stop();
  }
//*************************** END Read g.php Ethernet Data ***************************

for (i = 0; i < 6; i++) {
            Serial.print(DataRead[i],HEX);
          }
Serial.println("");
Serial.println("*******************");
Serial.print("Data Receive : ");
for (i = 0; i < sizeof(DataRead); i++) {
            Serial.print(DataRead[i]);
          }
Serial.println("");
Serial.print("Size Data : ");
Serial.println(sizeof(DataRead));
Serial.println("");

//*************************** START DATA traitement ***************************
uint32_t msdw, lsdw;

  uint8_t len = strlen(DataRead);
  Serial.print("len : ");
  Serial.println(len);
  
    msdw = strtoul(DataRead, NULL, 16);
    lsdw = strtoul(&DataRead[len-8], NULL, 16);


Serial.print("Adresse : ");
Serial.print(msdw, HEX);
Serial.print(" - ");
Serial.print(lsdw, HEX);
Serial.println(" ");

//*************************** END DATA traitement ***************************

  delay(3000); 
}