import de fichiers

**mimieloic** · 20/04/2015, 14h24

C'est Spare, en gros si pas 00 ni 01 ni 10 alors on ne met rien
regexp ? qu'est ce que ca veut dire?
merci

**Philou67430** · 20/04/2015, 14h58

Regexp = Expression régulière (motif de recherche). Ce sont les expressions notées entre des / / qui permettent de trouver et/ou d'extraire des motifs de textes comme /88(.{8,8})/ pour extraire 8 caractères quelconques qui suivent un 88.

**mimieloic** · 21/04/2015, 08h25

ah d'accord

**mimieloic** · 22/04/2015, 10h20

Avez vous besoin d'aide à la compréhension Philou?

**Philou67430** · 22/04/2015, 10h24

Non, pas pour l'instant... il me faut juste du temps.

Edit : si en fait : des exemples de décodage de trames 88

**mimieloic** · 22/04/2015, 11h23

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
07/02/2015	11:30:45	88060003C3750838678000E4900EB805410003800700A0B000000000	2	2154910	7536	2690
07/02/2015	11:30:55	88060003C4740838678000E4900EB805830003A0074080B000000000	2	2154910	7536	2822
07/02/2015	11:31:05	88060003C5730838678000E4900EB805BE0003A0074080B000000000	2	2154910	7536	2940
07/02/2015	11:31:15	88060003C6720838678000E4900EB805F4000300060080B000000000	2	2154910	7536	3048

les trois dernières colonnes sont le résultat à obtenir, le " 2" étant le résultat du précédent codage (cf message 81)

**Philou67430** · 22/04/2015, 14h05

Question, pour le multiplicateur basé sur les bits 96-97, le cas "00" et le cas "10" multiplient tous les deux par 10, c'est bien ça ? Faut-il utiliser l'unité pour l'afficher quelque part ?

**mimieloic** · 22/04/2015, 14h10

on multiplie mais on ne fait pas attention à l'unité ,enfin si possible juste mettre "m" si c'est mètre derrière

**Philou67430** · 22/04/2015, 14h19

Donc ajouter un m derrière le nombre pour des mètres ? (le script est presque près, juste ceci à ajouter, ensuite tu pourras tester).

**mimieloic** · 22/04/2015, 14h22

exactement

**Philou67430** · 22/04/2015, 14h26

J'ai un peu remanié le script (utilisation de fonctions pour le décodage) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
54
55
56
57
58
59
60
61
62
63
64
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
91
92
93
94
95
96
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
#!/usr/bin/perl
 
use strict;
use warnings;
use feature qw(:5.14);
 
# Le fichier résultat sera la sortie standard : utiliser > un_fichier.txt pour le stocker
 
# Récupération des paramètres d'appel du script (on affecte au tableau @in, le tableau @ARGV)
my @in = @ARGV;
@in = map glob($_), grep /[\*\?]/, @in;
 
# Pour tous les fichier en entrée
sub decode81($$);
sub decode88($;$);
foreach my $in (@in) {
  warn "Treating $in...\n";
 
  # Ouvrir le fichier backup (l'ancien fichier d'entrée) en lecture
  # et le fichier de sortie en écriture (le nouveau fichier d'entrée)
  open my $IN, "<", $in or die "Can't open file $in for reading: $!";
 
  # Déclarer un tableau pour les lignes 88 lues avant la ligne 81
  # et un scalaire pour le code décimal
  my (@kept_lines, $decoded);
 
  # Boucler sur toutes les lignes du fichier ouvert en entrée
  while (my $line = <$IN>) {
    # Supprimer les caractères de fin de ligne (mettre à jour la variable
    # $/ s'il ne s'agit pas de \n)
    chomp($line);
 
    # Récupération du timestamp et du code hexa de la ligne
    my ($timestamp, $code) = $line =~ /(.*?,).*,([\da-f]+)$/i;
 
    # Passer à la ligne suivante si le code n'est ni 81 ni 88
    next if !$code || $code !~ /^8[18]/;
 
    if ($code =~ /^81/) {
      # Si l'on a déjà décodé un code, le signaler, sinon simplement
      # indiquer que l'on décode
      warn "Line to decode found at $. in $in\n" if !$decoded;
      warn "New line to decode at $. in $in\n" if $decoded;
 
      # Sauvegarde de l'éventuel code décimal actuellement déjà décodé
      my $old_decoded = $decoded if $decoded;
 
      $decoded = decode81($code, $old_decoded);
 
      # Si l'on a stocké des lignes 88 précédent cette ligne 81, les traiter en ajoutant le code décimal
      if (@kept_lines) {
        map { say sprintf $_, $decoded } splice @kept_lines;
      }
    }
    # Si la ligne n'est pas une 81 (c'est donc forcément une 88)
    else {
      # Décoder la ligne 88
      if ($code = decode88($code, $decoded)) {
        # Si  le code décimal a été décodé
        # traiter la ligne en ajoutant le code décimal au timestamp et au code hexa
        if ($decoded) {
          say "$timestamp$code";
        }
        # Si la ligne n'est pas une 81 et que le code n'est pas décodé, enregistrer la ligne (timestamp et code hexa) pour un traitement
        # ultérieur (lors du traitement de la ligne 81 ; le code de la ligne n'étant pas encore connu, il est remplacé par %s qui servira de template pour sprintf)
        else {
          push @kept_lines, "$timestamp$code";
        }
      }
    }
  }
}
 
sub bin2hex($) {
  my ($bitcode) = @_;
 
  # La construction suit plusieurs étapes (pipeline de fonction à lire de droite à gauche) :
  # 1- substr($bitcode, $bitpos, 32) =~ /(.{4})/g : récupère le code binaire ASCII de 32 à la position $bitpos
  #                                                 et en extrait un tableau de chaines de 4 digit binaires
  #                                                 grâce à une recherche d'expression régulière globale
  # 2- map oct("0b$_") : pour chaque chaine binaire de 4 digits, convertir le code binaire ASCII en valeur numérique
  # 3- grep $_ < 10    : pour chaque valeur numérique, ne conserver que les valeurs inférieures à 10
  # 4- join ""         : concaténer sous forme "chaine" les digits décimaux ($decoded est alors une chaine
  #                      mais qui peut être utilisée dans un contexte numérique comme une valeur numérique)
  return join "", grep $_ < 10, map oct("0b$_"), $bitcode =~ /(.{4})/g;
}
 
sub decode81($$) {
  my ($code, $old_decoded) = @_;
 
  # Convertir le code hexa en binaire
  # La transformation s'opère en deux temps :
  # pack("H*", $code) code en "binaire" le code hexa récupéré sous forme ASCII
  # puis unpack("B*", ...) décode le "binaire" en code binaire sous forme ASCII
  # "binaire" signifiant ici de vrai binaire numérique (comme il est stocké dans un entier numérique).
  # Les formats majuscules imposent un sens de code hexa et binaire "MSB" first (bit de poids fort en premier)
  my $bitcode = unpack("B*", pack("H*", $code));
  my $bit75 = substr($bitcode, 74, 8);
 
  # Déclaration d'une variable qui contiendra la position des 32bits à décoder
  my $bitpos;
  if ($bit75 eq "00000000") {
    my $bit171 = substr($bitcode, 170, 2);
    if ($bit171 eq "00" || $bit171 eq "11") {
      $bitpos = substr($bitcode, 185, 1) eq "1" ? 217 : 209;
    }
    else {
      $bitpos = substr($bitcode, 200, 1) eq "1" ? 232 : 224;
    }
  }
  elsif ($bit75 eq "00000001") {
    my $bit194 = substr($bitcode, 193, 2);
    if ($bit194 eq "00" || $bit194 eq "11") {
      $bitpos = substr($bitcode, 209, 1) eq "1" ? 241 : 232;
    }
    else {
      $bitpos = substr($bitcode, 222, 1) eq "1" ? 254 : 246;
    }
  }
 
  # Construction du code décimal
  my $decoded = bin2hex(substr($bitcode, $bitpos, 32)) if $bitpos;
 
  # Trivial
  if ($old_decoded) {
    if ($decoded != $old_decoded) {
      warn "-> new decoded value is different from first occurence: old = $old_decoded, new = $decoded\n";
    }
    else {
      warn "-> same value ($decoded == $old_decoded)\n";
    }
  }
 
  return $decoded;
}
 
sub decode88($;$) {
  my ($code, $code81) = @_;
 
  my $decoded = $code;
 
  # Si le code de la ligne 81 n'est pas encore connu, il est remplacé par %s qui servira de template pour sprintf
  $code81 //= "%s";
  my @decoded = ($code81);
 
  # Convertir le code hexa en binaire
  my $bitcode = unpack("B*", pack("H*", $code));
  my $bit75 = substr($bitcode, 74, 8);
 
  # Déclaration d'une variable qui contiendra la position des 32bits à décoder
  my $bitpos;
  if ($bit75 eq "00000000") {
    my $bit171 = substr($bitcode, 170, 2);
    if ($bit171 eq "00" || $bit171 eq "11") {
      # Test du bit 186
      if (substr($bitcode, 185, 3) ne "011") {
        $decoded = undef;
      }
    }
    else {
      # test du bit 201
      if (substr($bitcode, 200, 3) ne "011") {
        $decoded = undef;
      }
    }
  }
  elsif ($bit75 eq "00000001") {
    my $bit195 = substr($bitcode, 194, 2);
    if ($bit195 eq "00" || $bit195 eq "11") {
      # Test du bit 210
      if (substr($bitcode, 209, 3) ne "011") {
        $decoded = undef;
      }
    }
    else {
      # test du bit 225
      if (substr($bitcode, 224, 3) ne "011") {
        $decoded = undef;
      }
    }
  }
 
  if ($decoded) {
    # Decoder les bit 51 à 74
    push @decoded, bin2hex(substr($bitcode, 50, 74-51));
 
    # Decoder les bits 108 à 122
    push @decoded, bin2hex(substr($bitcode, 107, 122-108));
 
    # Test du bit 82 pour décodage dernière colonne
    my $bit82    = substr($bitcode, 81, 1);
    my $last_col = bin2hex(substr($bitcode, $bit82 eq "0" ? 122 : 146, $bit82 eq "0" ? 138-123 : 162-147));
 
    # Decodage du multiplicateur
    my $bit96 = substr($bitcode, 95, 2);
    my $multi = $bit96 eq "00" || $bit96 eq "10" ? 10 : $bit96 eq "01" ? 1 : undef;
    my $last_col_unit = $bit96 eq "10" ? "m" : ""; 
    push @decoded, ($last_col * $multi).$last_col_unit if $multi;
 
    $decoded = join "\t", $code, @decoded;
  }
 
  return $decoded;
}

**mimieloic** · 22/04/2015, 14h32

alors il n'y pas eu de réponse
le fichier est créé mais vite, et aucun message dans la windows do

j'ai écris perl chemin-de-mon-programme chemin-de-mes-fichiers > fichier.txt

**Philou67430** · 22/04/2015, 14h50

Pardon, je suis reparti du script que j'avais écris initialement, qui ne prend pas en compte le paramètre de Lolo.
Pour l'utiliser :

perl script.pl *.* > fichier.txt

remplacer *.* par la liste des fichiers à traiter (*.extention)

**mimieloic** · 22/04/2015, 14h54

pour la liste des fihciers je mets le chemin.eur ou *chemin.eur * ?

**mimieloic** · 22/04/2015, 14h57

j'ai reussi, je regarde si c'est le bon résultat

**mimieloic** · 22/04/2015, 15h01

j'obtiens

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
2014/10/20 15:51:11,88060000BC28C83FFF4000E490000280255001A00345083000000000	5	20	001	9
2014/10/20 15:51:18,88060000BCD5483FFF4000E490000380270001A00345003000000000	5	20	001	9
2014/10/20 15:51:21,88060000BD20483FFF4000E490000480240001A00345003000000000	5	20	002	9
2014/10/20 15:51:23,88060000BD51083FFF4000E490000480900001C00385003000000000	5	20	002	24
2014/10/20 15:51:28,88060000BDD0883FFF4000E490000481A80002000404E03000000000	5	20	002	6
2014/10/20 15:51:33,88060000BE50083FFF4000E490000482BC0002400484E03000000000	5	20	002	0
2014/10/20 15:51:38,88060000BECF883FFF4000E490000483CF0002800504E03000000000	5	20	002	3
2014/10/20 15:51:39,88060000BEE6083FFF4000E4900005802B5001A00344E83000000000	5	20	002	0
2014/10/20 15:51:44,88060000BF4F083FFF4000E490000680250001A00344C03000000000	5	20	003	9
2014/10/20 15:51:49,88060000BFCE883FFF4000E490000681310001E003C4C03000000000	5	20	003	4
2014/10/20 15:51:54,88060000C04E083FFF4000E490000682390002200444A03000000000	5	20	003	8
2014/10/20 15:51:59,88060000C0CD883FFF4000E490000683440002400484C03000000000	5	20	003	1

au lieu du 20 je devrais avoir : 2162685

**Philou67430** · 22/04/2015, 15h01

Tu as mis quoi au final ?
Si tu es sous windows, le mieux est d'aller dans le dossier où sont les fichiers (commande(s) cd) puis :
perl script.pl *.eur >fichier.txt

**mimieloic** · 22/04/2015, 15h03

j'ai mis le chemin\*.eur

oui c'est aussi une alternative possible

**mimieloic** · 22/04/2015, 15h07

peut etre que le probleme vient que cette fois ci les codages sont en 2^1
2^2 sur les 15 , 14 ou 24 bits?
car sinon je vois pas pk ca donnerait pas le bon résultat

**Philou67430** · 22/04/2015, 15h18

J'ai pas vu qu'il y avait une différence de codage ... effectivement, on est passé de MSB first à LSB first.

Ce codage concerne toutes les colonnes des lignes 88 ?

import de fichiers

Langage Perl

Discussions similaires

Partager

Partager