élaboration motif expression régulière

Version imprimable

16/10/2019, 00h43
hary66

élaboration motif expression régulière

Bonjour

Je souhaite créer un motif pour "matcher" ceci :
(MMM.M NNN.N PPP.P QQQ RR.R S.SS TT.T b7b6b5b4b3b2b1b0<cr>

MMM.M (M is an integer number ranging from 0 to 9.)
NNN.N (N is an integer number ranging from 0 to 9.)
PPP.P (P is an integer number ranging form 0 to 9.)
QQQ (QQQ is a percentage)
RR.R (R is an integer number ranging from 0 to 9.)
SS.S or S.SS (S is an integer number ranging from 0 to 9.)
TT.T (T is an integer number ranging form 0 to 9.)
b7b6b5b4b3b2b1b0. Where bn is a ASCII character ‘0’ or ‘1’.
Stop Byte : <cr>
Example:
(208.4 140.0 208.4 034 59.9 2.05 35.0 00110000<cr>

J'utilise ce lien pour m'aider à préparer ma regex. :
https://regexper.com/#R%22%28%5B%5C%...B%5Cr%5D%29%22

Ca se rapproche de ce que je souhaite retrouver mais je ne sais pas comment élaborer la partie du motif correspondant à :
SS.S or S.SS
Je ne sais pas comment faire l'un ou l'autre ?

D'autre part, j'utilise {3} pour dupliquer le motif 3 fois, mais je ne le vois reproduit que 2 fois (n-1 fois) dans la "simulation".
16/10/2019, 02h28
jo_link_noir

Il te faut utiliser un ou (ab|bc pour ab ou bc). Éventuellement en mettant le tout dans des parenthèses. Je n'ai rien vu de tel sur le cours de guillaume, c'est une présentation rapide des regex. Il doit y avoir un cours complet sur les regex ici.

Concernant l'écriture de la regex, tu peux simplifier [\d] en écrivant seulement \d. Idem pour [\.] qui s'écrit soit [.] soit \.. Du moment qu'il n'y a qu'un seul identifiant, les crochets ne sont pas utiles.

Citation:

D'autre part, j'utilise {3} pour dupliquer le motif 3 fois, mais je ne le vois reproduit que 2 fois (n-1 fois) dans la "simulation".

C'est normal. Si on demande a{1}, on traverse un caractère. Pour a{2}, on le traverse 1 fois puis on recule 1 fois. Pour a{3}, on recule 2 fois. Ce qui s'affiche est le nombre de fois qu'il faut reculer, pas le nombre de fois que le motif est comptabilisé.
16/10/2019, 09h11
hary66

Super, merci.

J'arrive finalement à ceci :
R"(\((\d{3}\.\d\s){3}\d{3}\s\d{2}\.\d\s((\d{2}\.\d)|(\d\.\d{2}))\s\d{2}\.\d\s[01]{8}\r)"
https://regexper.com/#R%22%28%5C%28%...8%7D%5Cr%29%22

Je pense que cela correspond bien au motif recherché qui est :
(MMM.M NNN.N PPP.P QQQ RR.R S.SS TT.T b7b6b5b4b3b2b1b0<cr>
ou
(MMM.M NNN.N PPP.P QQQ RR.R SS.S TT.T b7b6b5b4b3b2b1b0<cr>

Merci pour le coup de main.
16/10/2019, 09h50
hary66

Bon, apparemment, pour utiliser les REGEXP avec l'IDE Arduino, il faut un motif élaboré pour LUA qui est différent de celui que j'ai préparé ("Emac standard")

Déjà que les REGEXP ne sont pas simples à mettre en œuvre, mais si en plus il y a plusieurs "standard" !!!
16/10/2019, 17h25
jo_link_noir

Oui, il y a des standards plus ou moins poussés, mais si c'est les mêmes "regexp" qu'en Lua (en minuscule, ce n'est pas un acronyme), bah, ce n'est pas des regex, mais des "patterns": https://www.lua.org/manual/5.3/manual.html#6.4.1

La grosse limitation concerne l'absence de | (entre autres) ce qui rend le moteur simple et rapide, mais aussi limité. Autres modifications majeurs, le caractère d’échappement est % plutôt que \, et le qualifieur - existe en tant que version non-gourmande de * (*? pour les regex perl).

Soit il faut utiliser 2 regex, soit tricher un peu avec \d[\d.]{2}\d qui accepte aussi SSSS ou S..S et faire éventuellement un post traitement.

Tu peux donner un lien vers la doc ?
16/10/2019, 21h50
hary66

1 pièce(s) jointe(s)

Je suppose que tu demandes la doc du matériel avec lequel je souhaite communiquer et dans le cas présent vérifier que l'info renvoyée est bien de la forme attendue ?

Pièce jointe 510433

Sinon le lien correspondant pour traiter les regexp en Arduino.
http://www.gammon.com.au/forum/?id=11063
16/10/2019, 22h44
CosmoKnacki

Pour résoudre le problème du SS.S or S.SS, il doit être possible d'utiliser l'assertion %f[set] qui impose que la position soit suivie par un élément du set et qu'elle ne soit pas précédée par un élément du même set. Ça donnerait ça:

Code:

%f[0-9]([0-9][0-9][.][0-9]%f[ ])?([0-9][.][0-9][0-9])?

Les deux formes sont mises dans des groupes optionnels. La première assertion (qui est précédée d'un espace) %f[0-9] impose qu'au moins un des deux groupes réussisse. La seconde assertion %f[ ] impose elle, en cas de réussite du premier groupe que celui-ci soit suivi d'un espace, ce qui exclut que le deuxième groupe réussisse en même temps.

Désolé si la syntaxe est un peu brute mais j'ignore si on peut l'écrire de cette manière:

Code:

%f[%d](%d{2}\.%d%f[ ])?(%d\.%d{2})?

(Je n'ai rien pour tester, je ne sais pas si la classe %d doit s'entendre en ASCII ou en unicode, et si l'antislash est bien le caractère d'échappement pour les caractères spéciaux).