Bonjour à toutes et à tous !

Je ne suis pas certain d'être dans la bonne section sachant que je veux porter un programme en C, mais bon y a tout de même du Python dans l'affaire alors...

Entrons dans le vif du sujet, j'ai un script en Python qui permet de communiquer avec un Bitscope BS05U (http://my.bitscope.com/store/?p=view&i=product+BS05U) pour faire de l'échantillonnage continu.

Le script fonctionne bien mais est limité à 200KHz d'après le support bitscope, je veux donc faire un portage en C pour voir si cela améliore les perfs. J'ai porté la majorité du programme mais une fonction me pose problème.

Le bitscope me renvoie des blocs de données hexadécimales et dans le programme Python ces données sont envoyées à la fonction
decodeFrames(data) qui renvoie un tableau d'entiers (les valeurs numériques représentant ma tension analogique). Voici la fonction :

def decodeFrames(data):
    couples = int(len(data) / 2)
    #print(data)
    unpackArg = "<" + str(couples) + "h"
    #print(couples)
    #print(unpackArg)
    unpacked = struct.unpack(unpackArg, data)
    #print(unpacked)
    #zeroBottomNibble = lambda x : x >> 4 << 4
    #result = list(map(zeroBottomNibble, unpacked))
    return unpacked

L'essentiel du décodage réside en l'appel struct.unpack("< nbdata / 2 h", data) si je me fie à la doc du Python cela permet de convertir des structure compatible C en structure Python. Le '<' signifiant little-endian et le 'h' short. J'en ai déduit que 2 caractères hexa de données représentent un short.

J'ai donc essayé ce genre de choses en C :

unsigned char c [2];
short * p;

p = & c ;

while(1) {
  c [1] = readOneChar ();
  c [0] = readOneChar ();

  printf ( "%x  %d\ n" , *p , *p);
  }

Mais ça ne donne pas de résultats probants. J'envoie une sinusoïde en entrée de mon bitscope et le script Python me sort bien une sinusoïde alors que le programme C renvoi des valeurs très étranges.

Voilà un extrait de la sortie du script python :

b'\xe5\xe9\xfa\xe9\xf5\xe9\n\xea\x15\xea*\xea5\xea:\xeaE\xeaZ\xeae\xeaz\xeae\xeaz\xea\x85\xea\x9a\xea\x95\xea\xaa\xea\xb5\xea\xba\xea\xc5\xea\xda\xea\xe5\xea\xea\xea\xf5\xea\n\xeb\x15\xeb*\xeb5\xebJ\xebE\xebJ\xebe\xebz\xebe\xeb\x8a\xeb\x95\xeb\x9a\xeb\xa5\xeb\xaa\xeb\xc5\xeb\xca\xeb\xd5\xeb\xea\xeb\xf5\xeb\n\xec\x05\xec\x1a\xec%\xec*\xecU\xecZ\xece\xecj\xecu\xec\x8a\xec\x95\xec\x9a\xec\xa5\xec\xba\xec\xc5\xec\xda\xec\xe5\xec\xea\xec\xe5\xec\n\xed\x05\xed*\xed5\xed:\xedU\xedZ\xede\xedj\xede\xed\x8a\xed\x85\xed\x9a\xed\xb5\xed\xca\xed\xc5\xed\xda\xed\xf5\xed\n\xee\x05\xee\x1a\xee%\xee*\xeeE\xeeJ\xeeU\xeej\xeeu\xee\x9a\xee\x85\xee\xaa\xee\xb5\xee\xca\xee\xc5\xee\xea\xee' // les données "bruts"
100 // couples
<100h // unpackArg
(-5659, -5638, -5643, -5622, -5611, -5590, -5579, -5574, -5563, -5542, -5531, -5510, -5531, -5510, -5499, -5478, -5483, -5462, -5451, -5446, -5435, -5414, -5403, -5398, -5387, -5366, -5355, -5334, -5323, -5302, -5307, -5302, -5275, -5254, -5275, -5238, -5227, -5222, -5211, -5206, -5179, -5174, -5163, -5142, -5131, -5110, -5115, -5094, -5083, -5078, -5035, -5030, -5019, -5014, -5003, -4982, -4971, -4966, -4955, -4934, -4923, -4902, -4891, -4886, -4891, -4854, -4859, -4822, -4811, -4806, -4779, -4774, -4763, -4758, -4763, -4726, -4731, -4710, -4683, -4662, -4667, -4646, -4619, -4598, -4603, -4582, -4571, -4566, -4539, -4534, -4523, -4502, -4491, -4454, -4475, -4438, -4427, -4406, -4411, -4374) // la trame décodée

Si on prend les deux dernières valeurs de la trame brut : 0xea et 0xee, EAEE; que l'on inverse le sens : EEEA; et que l'on convertie en décimal signé on tombe sur : -4374; On a donc fait la même chose que le script python, non ?

Mon programme C tente de faire cette opération qui a l'air simple mais échoue lamentablement. Vous avez une idée ?