Bonjour à tous, j'ai récemment travaillé sur le mode PDU.. Pour ceux qui ne savent pas ce que c'est, c'est le mode de cryptage d'informations pour envoyer un SMS.. Le but est d'envoyer un sms à partir de son ordinateur

Je vais essayer d'être assez clair dans mes explications

Chaque lettre avant d'être envoyé est :
- remplacée par sa valeur ASCII
- Ensuite traduite en Binaire mais sur 7 bits
- Ensuite traduire le binaire 7 bits sur une base 7 de 8 bits (et c'est la que c'est drôle ^^ )
- Pour finalement le traduire en Hexadécimal et envoyé l'infos.

Les sources :
http://www.dreamfabric.com/sms/ (pour l'envoi complet d'un sms)
http://www.dreamfabric.com/sms/hello.html (pour la base 7 sur 8 bits)

En principe mon code est prévu pour que peu importe la taille du sms il passe.. Je n'ai pas encore su faire TOUT les tests.. Mais il semble plus que correct. Et par solidarité je vais le poster non pas pour ceux qui seront fainéant de le faire un jour, mais pour ceux qui après de longues recherches auront trouvés que très peu d'infos utiles..

(Veuillez excuser si par endroit il n'est pas le plus optimisé des codes mais s'y retrouver n'était pas une mince affaire ^^)

Tout d'abord en PDU la table ascii n'est pas la même.. ils utilisent une codification un peu différente (http://www.dreamfabric.com/sms/default_alphabet.html)..
J'ai donc déclaré 2 tableaux. Le premier avec les 127 caractères et le deuxième avec les caractères de sortie.
Je recherche dans mon tableau la valeur ascii et si je trouve je renvoi l'indice (qui lui vaudra la valeur modifiée de leur table)

Code :
1
2
3
4
5
6
gtabPDU est un tableau de 137 entier
gtabEscUnicode est un tableau de 10 entier

gtabPDU= [64,163,36,165,232,233,249,236,242,199,10,216,248,13,197,229,-1,95,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,198,230,223,201,32,33,34,35,164,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,161,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,196,214,209,220,167,191,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,228,246,241,252,224,12,94,123,125,92,91,126,93,124,164]
gtabEscUnicode = [12,94,123,125,92,91,126,23,124,164]
On écrit un texte et on le converti en Hexa pour le convertir en binaire sur 7 bits.

Code :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
LIB_Ascii = ""
LIB_Bin = ""

nValeur est un entier
svaleur2 est une chaîne
nResindice est un entier


POUR i = 1 _A_ Taille(SAI_Texte)
	nValeur = Asc(Milieu(SAI_Texte,i,1))
	nResindice = TableauCherche(gtabPDU,tcLinéairePremier,nValeur) -1 
	SI nResindice <> -1 ALORS
		SI nResindice > 127 ALORS
			nValeur = nResindice - 127
			nResindice = gtabEscUnicode[nValeur]
			SI nResindice = -1 ALORS 
				Erreur("Caractère non supporté")
				SORTIR 
			FIN
		FIN
		LIB_Ascii += nResindice + " " 
		svaleur2 = numériqueversbase(nResindice,2,7)
	SINON 
		Erreur("Caractère non supporté ")
	FIN	
	LIB_Bin +=  svaleur2
FIN
Une fois qu'on obtient le binaire sur 7 bits on le passe en 8 bits comme décrit plus haut pour obtenir une base 7 de 8 bits.

Code :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
sChai1, sChai2, sChai3, sChai4 sont des chaîne ANSI
i, nDim1, k, j, m est un entier = 0
nTest est un entier 
nCompt,nCompt2 est un entier
nDim1 = (Taille(LIB_Bin)/7)
tab1 est un tableau de nDim1 chaînes ANSI
tab2 est un tableau de nDim1 chaînes ANSI

LIB_Hexa = ""


POUR i = 0 _A_ nDim1
	// On va lire les 7 bits
	sChai1 = Lecture7Bit(i)
	// On tronque les M bits à droites
	sChai2 = TruncD(sChai1, m)
	// On tronque les M bits à gauche
	sChai3 = TruncG(sChai1, m)
	nTest = modulo(i,8)
	SI nTest = 0 ALORS
		m = 0
	FIN
	m++
	
	SI i <> 0 ALORS
			j++
			tab2[j] = sChai2	
	FIN
	k++
		SI k < nDim1+1 ALORS
				tab1[k] = sChai3 
		FIN
FIN
POUR i = 1 _A_ nDim1
	SI i+1 <= nDim1 ALORS
		SI tab1[i+1] <> EOT  ALORS
			sChai4 += tab2[i] + tab1[i]
		SINON
			sChai4 += tab2[i+1] + tab2[i]
			tab1[i+1] = ""
			tab2[i+1] = ""
		FIN
	SINON
		sChai4 += tab2[i] + tab1[i]
	FIN
FIN
//Affiche résultat
LIB_B7 = sChai4
//Calcul des nombres à convertir en hexa ! 
nCompt = Taille(sChai4) /8
nCompt2= modulo(Taille(sChai4),8)

proc_Hexa(nCompt,nCompt2)
Procédure lecture7bit
Code :
1
2
3
4
5
6
7
PROCEDURE Lecture7Bit(Ind)
sLChaine est une chaîne = LIB_Bin
sResul est une chaîne ANSI

sResul = Milieu(sLChaine, (Ind*7 + 1), 7)

RENVOYER sResul
Procédure TruncD
Code :
1
2
3
4
5
6
PROCEDURE TruncD(mChaine, Ind)

sMResult est une chaîne ANSI

sMResult = Droite(mChaine, Ind)
RENVOYER sMResult
Procédure TruncG
Code :
1
2
3
4
5
6
7
PROCEDURE TruncG(dChaine, Ind)

sDResult est une chaîne ANSI

sDResult = Gauche(dChaine, (7 - Ind))

RENVOYER sDResult
et finalement on convertit tout ça en hexadécimal

Code :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
PROCEDURE proc_Hexa(nCompt,ncompt2)
nInd est un entier = 0
nTemp est un entier
nTemp2 est un entier


POUR i = 1 _A_ nCompt
	nTemp = Milieu(LIB_B7,(nInd*8 +1),8)
	nTemp2 = Val(nTemp,2)
	LIB_Hexa+= Droite(EntierVersHexa(nTemp2),2)
	nInd ++
FIN
SI ncompt2 <> 0 ALORS 
	nTemp = Droite(LIB_B7,ncompt2)
	nTemp2 = Val(nTemp,2)
	LIB_Hexa += Droite(EntierVersHexa(nTemp2),2)
FIN
On obtient notre bout de code. (maintenant il ne reste plus qu'à faire l'inverse pour décoder la réception de message )

J'espère que ce tuto vous sera très utile.


Bonne continuation à tous, et long vie à ce forum !