Bonjour,
je cale sur un problème, un peu d'aide serait appréciée ! je débute, désolé si ma question semble idiote ;
mais j'ai beaucoup cherché, et là, j'y arrive plus...

Je voudrais recréer des variables numériques ($Valeur1, 2, 3, ...)
à partir d'une variable $bufBINAIRE qui est remplie par la lecture d'un fichier qui contient des Words (16 bits)

Mes variables recalculées ($Valeur1 ...) ont toujours pour valeur 0, alors
que j'ai bien les bonnes valeurs binaires dans $WORDS[$i][0]) et $WORDS[$i][1])

J'ai essayé de transtyper mes variables, mais cela ne résoud rien.
Qu'ai-je mal fait ? merci...

<?php

  // pour commencer, 
  // $bufBINAIRE reçoit des valeurs binaires (16 bits) lues dans un fichier
  // ces valeurs sont jointives dans le fichier, et  donc dans bufBINAIRE
  // (8 bits + 8 bits)  (8 bits + 8 bits)  (8 bits + 8 bits)  (8 bits + 8 bits) ...
 
  {
    // je découpe BufBINAIRE en Blocs de 2 caractères 
    $WORDS = str_split($bufBINAIRE, 2);


     // et je (tente de) convertir chacun des bloc de 2 octets en 1 variable 
     // qui reflète mon Word d'origine (celui qui était dans le fichier en lecture)
    for($i=1; $i<=count($WORDS)-1; $i++)  
    { 
      $Valeur1  = ($WORDS[$i][0]) + ($WORDS[$i][1] * 256);
      $Valeur2  = ($WORDS[$i][2]) + ($WORDS[$i][3] * 256);      
      $Valeur3  = ($WORDS[$i][4]) + ($WORDS[$i][5] * 256);
    }
  }
}
?>

// et  là , mes variables $Valeur sont toujours à 0 ...

Salut,

Je suis pas sûr d'avoir 100% compris ton exemple, mais regarde ce petit bout de code :

$bufBINAIRE = '0101110101110101';
//buf binaire contient 16 bits aléatoires

// je découpe BufBINAIRE en Blocs de 2 caractères 
$WORDS = str_split($bufBINAIRE, 2);
// COMM : on recupere $WORDS[O...7] 


$nomvariable = 'Valeur';
$comptagenomvariable = 1;

for ($i = 0; $i < count($WORDS) - 1; $i+=2) {
    $nomvariablesortie = $nomvariable . $comptagenomvariable;
    $$nomvariablesortie = ($WORDS[$i]) + ($WORDS[$i + 1] * 256);
    $comptagenomvariable++;
    /* Revient au même que de faire :
     * $Valeur1 = index 0 + index 1 *256
     * $Valeur2 = index 2 + index 3 *256
     * $Valeur3 = index 4 + index 5 *256
     * $Valeur4 =index 6 + index 7 *256
     */
}

echo $Valeur1 . '<br />';
echo $Valeur2 . '<br />';
echo $Valeur3 . '<br />';
echo $Valeur4 . '<br />';

Il me semble, battez-moi si je me trompe :
Pour ton problème, déjà tu as des accolades en trop. Après, si tes variables prennent pas la valeur (et te génèrent une erreur ?), c'est car tes index $WORDS[$i][0...5] n'existent pas.
Ta variable words prends (si $bufBinaire a le contenu de l'exemple précédent) :

array(8) {
[0]=>
string(2) "01"
[1]=>
string(2) "01"
[2]=>
string(2) "11"
[3]=>
string(2) "01"
[4]=>
string(2) "01"
[5]=>
string(2) "11"
[6]=>
string(2) "01"
[7]=>
string(2) "01"
}

Donc tu peux utiliser $WORDS[$i][0] et $WORDS[$i][1] seulement. Et ce, pour un i qui va de 0 à 7.

Est ce que ça t'avance ? En tout cas j'espère ne pas te retarder de trop,
Bon courage,
Computarelier

Merci Computarlier, oui, ça m'avance ce que tu m'indiques, je bosse et apprends ; il semblerait que le PHP ne soit pas bien prévu pour gérer des trames binaires, ou alors je me trompe ; dès que j'ai un peu mieux pigé, je donne mon résultat.
Merci encore

Bien sûr que si que PHP peut travailler sur du binaire.
http://julien-pauli.developpez.com/tuto ... p/bool-op/

Ensuite dans ton algo il y a un truc qui me hérisse le poil...
Tu fais une boucle mais tu écrases à chaque itération tes variables.

Naaaaan, fais attention à tes poils, pas la peine de te les calciner le code que j'ai recopié ici a été expurgé de tout ce qui n'était pas nécessaire, pour plus de lisibilité, et j'ai un peu taillé brutalement, mais il fonctionnait logiquement bien (sauf que je n'arrivais pas à récupérer dans le bon ordre mes valeurs). Je voulais savoir comment extraire des octets qui arrivaient de l'extérieur dans mes variables sans qu'une fonction locale de saisie en PHP ne les aient engrangés .

Je sais que le PHP peut traiter le binaire, mais j'ai moins de 3 heures de PHP (j'ai un un peu plus d'expérience dans d'autres langages, dont celui qui utilise quelque peu le binaire et qui accède aux registres du processeur, lol).

Bon ça y est, j'ai utilisé la fonction "unpack" pour récupérer mes octets dans le bon format ; pour les copains, je mettrais le code en exemple, et j'appuierai sur le bouton "Résolu". Au fait, merci pour ton lien, mais tu aurais pu aussi généreusement m'indiquer ton approche perso, ça aurait été bien. Mais ça fait rien.

Bon, que le Seigneur vous bénisse et vous garde. Très sympa, ce site !

.

Je n'avais pas eu le temps de penser à un petit bout de code donc j'en suis resté à ce lien.

Voilà ce que j'aurai fait pour ma part :

$buffer = 0b01011101011101011111000011001110; // attention notation uniquement disponible à partir de PHP 5.4
$result = array();
while($buffer > 0)
{
  $byte = $buffer & 0xFF;
  array_push($byte);
  $buffer = $buffer >> 16;
}

Pas testé.
Travaillant tous les jours avec des données de type binaire c'est ce qui me semble le plus propre.

.
Ah ben il faut le tester alors !!!


Voilà ma solution. Le piège est que PHP fixe le type de la variable en fonction du format de la donnée qu'on lui fournit.
Ça doit faciliter la vie du codeur quand il se limite à utiliser les variables pour les tâches courantes, mais vachement déroutant si on veut la traiter un peu différemment, comme moi qui découvre ça.
Bien sûr, si j'avais eu un pote à coté de ma chaise qui me l'ait dit, j'aurais pas cherché tout seul dans mon coin. Fallait le savoir.

Pour moi qui reçoit une trame organisée en mots de 8 bits (une chaine d'unsigned char) le plus simple c'est la fonction unpack :

<?php
// les  3 valeurs suivantes sont identiques, mais pas leur formatage dans $buffer...
// intervertir les lignes pour tester !
  
  $buffer = 1568010446;                          // notation décimale          
  $buffer = 0b01011101011101011111000011001110;  // notation binaire  >=  PHP 5.4
  $buffer = "\x5D\x75\xF0\xCE";                  // notation hexadécimale (char 8 bits)

  $array1 = unpack("C*", $buffer);
 
  printf('   0x%X    0x%X    0x%X   0x%X  <br>',   $array1[1], $array1[2], $array1[3], $array1[4]); 
?> 

Resultat : 0x5D 0x75 0xF0 0xCE se retrouvent là où y faut dans mes variables $array1[x]

On peut spécifier un formatage différent de $buffer, voir la commande "pack".
A noter qu'avec unpack, les index commencent à 1...
Et voilà.

Ah ben il faut le tester alors !!!

Je ne travaille pas dans le dev web donc tester au boulot....