totof2000 a écrit 9656 commentaires

S'agit-il de supervision ou graphage ? Il faudrait que tu définisses précisément ce que tu veux faire.

Ensuite, quel contexte ? Une petite infra perso ou une infra pro qui s'étendra à l'avenir? Y aura-t-il des plugins spécifiques à développer ? Si c'est la seconde solution, ne prend pas ta décision à la légère. En effet dans le cas de développement plugins spécifiques, si tu as choisi une solution "basique" non compatiblme avec d'autres solutions, et que tu dois changer d'outil parce que celui-ci est trop limité, tu risques de te retrouver coincé, et ça risquie de couter cher.

Un formulaire html, ce serait plus simple, au moins tu es sur que c'est bien formé, et tu laisses les candidats faire le copier/coller de leur CV.

Ces shields doivent être basés sur le même principe. Et c'est sur le principe surtout que ma question portait.

Je me réponds à moi-même (j'aurais du commencer par là) :

http://www.eletronica.org/modules.php?name=News&file=print&sid=139

Peux-tu m'expliquer comment tu interfacerais de l'I2C sur du RS485? C'est une vraie question.

continuez à me soumettre des idées, je suis preneur !

A mon avis le choix du bus n'est pas anodin, et tu devrais te poser la question suivante :
- est-ce que les équipements sur le bus auront besoin d'émettre des messages sans forcément être interrogés par le maitre, et sui les esclaves devront dialoguer entre eux.

Si c'est oui, il vaut mieux passer par un bus de type CAN qui n'a pas de principe maître/esclave, mais tout le monde peut émettre des messages sur le bus. L'inconvénient, c'est un peu plus cher. l'avantage ; tu n'as pas à te prendre la tête avec des histoires de maitre/esclave et tout le monde peut communiquer avec tout le monde.

Dans le cas d'un bus maître/esclave, il te faudra pooler sans cesse les équipements de ton bus. Le bus I2C a un mode multimaitre mais tu ne peux pas multiplier les maitres à l'infini, et je ne me rappelle plus comment se passe le dialogue de maître à maitre (ni même si c'est possible) : je vais voir si j'ai encore des docs sur le sujet. Pour le modbus, il y a un seul maître de bus me semble-t-il.

Dans le cas ou tu as un seul maitre et des esclaves qui doivent discuter entre eux, il te faudra gérer la communication entre esclaves. Il me semble que durant mes études, j'avais fait un TP comme ça sur Modbus, avec un protocole à base de jeton que le maître envoyait tour à tour à chaque esclave (le maitre ne faisait que ça, gestion des communications et non-réponse des esclaves). Chaque esclave répondait au maître en supprimant les messages qui lui étaient destinés et en ajoutant ceux qu'il voulait ajouter à destination des autres esclaves. Je pense que ce genre de protocole sera difficile à réaliser avec I2C, ou les messages échangés sont plus ou moins imposés par l'état des composants sur le bus.

+1 pour le site, je ne connaissais pas …

Personnellement je n'utiliserais pas I2C sur ce genre d'application, je passerais plutôt par Modbus ou CAN.

pour des raisons de pingrerie, je voudrais d'abord utiliser le minimum de matériel et me baser sur la prise USB de l'Arduino

Entre le cout des cables USB (longs ?) , du hub, la mise en place, etc …. au final ça risque de revenir cher. Sinon que veux-tu dire par "baser sur la prise USB de l'Arduino que j'utiliserais en bus série pour communiquer avec le serveur" ? J'ai un peu de mal à comprendre ce que tu veux faire en fait.

Sinon si tu tiens absolument à mettre des cables, il y a aussi modbus; Je me souviens l'avoir utilisé durant mes études : ce n'est pas très complexe à utiliser, il me semble que nous utilisions une liaison RS485. Et tu peux trouver des transceivers pour pas cher

Mais bon, à toi de voir.

Tu devrais peut-être passer par du wifi, du CPL (mais un peu cher à mon gout) ou par un bus de type CAN par exemple.

Pour un module CAN : http://lnxpps.de/rpie/

Un module tout fait, mais un peu cher : http://skpang.co.uk/catalog/pican-canbus-board-for-raspberry-pi-p-1196.html

Il y a peut-être des bus qui seraient un peu mieux adaptés à ton besoin

(exemple : http://djynet.net/?p=185).

En Python tu peux faire exactement la même chose avec des chaînes de caractères. Le module logging a fait un choix différent, mais ça ne veut pas dire que ce n'est pas possible.

Ce n'est pas la première fois que je rencontre ce genre de cas de figure : avoir un type dédié permet de ne pas se poser de question lorsque tu rencontre une chaine de caractère, savoir si elle est utilisée comme symbole ou comme chaine. A la lecture c'est plus simple à comprendre.

C'est comme beaucoup de choses : on se dit qu'on en a pas besoin tant qu'on ne l'utilise pas, puis quand on se retrouve à l'utiliser on se rend compte après qu'il est difficile de s'en passer.

En Ruby ça donnerait quoi ? Il n'y aurait pas besoin d'enum et possibilité de mettre :gauche, :droit et :eteint ?

Oui.

Au niveau du typage, ça donnerait quoi ?

Un symbole qui est un type à part entière.

OK, je viens de voir tes messages suivant et j'ai compris: ton problème est que l'utilisation des enums comme des symboles viole la règle DRY(Don't Repeat Yourself) (enum TOTO='TOTO')

Entre autres … :)

Tu aurais expliqué ça dès le début, ça aurait été plus clair..

Je t'avoue que le symbole est un concept que j'ai eu du mal à comprendre quand j'ai commencé le Ruby, mais qui me parait tellement évident aujourd'hui que j'ai du mal à l'expliquer.

Ceci dit, je n'aime pas trop les symboles car ils sont préfixés par :, #, \ (dépend du langage), alors que les enums non.

Tant qu'à rajouter une notation magique pour éviter les répétitions, moi j'aurais fait enum TOTO@ (équivalent de enum TOTO='TOTO') et hop, le moche symbole ne se voit que dans la déclaration de l'enum, est-ce que ça te conviendrait maintenant?

Non parce que tu utilises un objet associatif pour une représentation qui ne l'est pas. L'avantage du symbole est qu'il ne représenter que lui même. Tu n'as pas d'association arbitraire à déclarer nulle part.

En Erlang par exemple, tu différencies l'équivalent du symbole (atom) car il commence en minuscule, contrairement à une variable qui elle commence par une majuscule.

A la limite, tu pourrais je pense utiliser une chaine de caractère là ou on utilise le symbole en ruby, par contre quelque part ça prête à confusion dans le code, vu que le rôle des deux n'est pas tout à fait le même

Je ne comprends pas ta question

Je vais en poser une autre alors: supposons que tu aies un objet représentant une commande de clignotant dans une voiture : ton clignotant peut être dans 3 positions : gauche, droit ou éteint. Comment représenterais-tu celà en Python ?

ni le rapport avec la "nécessité" d'avoir les symboles en plus des enums "à la Python".

Peut-être comprendras-tu mieux après.

Qu'est-ce qu'un enum en Python ? c'est ni plus ni moins qu'une structure associative. Pour t'aider à comprendre : suppose qu'en Python tu dois représenter l'état d'une LED : allumé et éteint. Comment fais-tu ?

L'intérêt c'est d'avoir un ordre bien défini (ERROR est plus grand que WARNING, etc.)

Et pourquoi ? Personnellement, en tant qu'utilisateur de l'API j'en ai rien à faire non ? C'est du détail d'implémentation ça.

Je ne vois pas le rapport avec les "symboles" Ruby, mais peut-être que quelque chose m'échappe.

En ruby tu définis des symbole ERROR, WARNING INFO et DEBUG. Tu ne leur attribue aucune valeur correspndante : le symbole se suffit à lui même.

Je viens d'aller voir le module logger, et comme je le craignais, on a un truc affreux comme ça :

_levelNames = {
    CRITICAL : 'CRITICAL',
    ERROR : 'ERROR',
    WARNING : 'WARNING',
    INFO : 'INFO',
    DEBUG : 'DEBUG',
    NOTSET : 'NOTSET',
    'CRITICAL' : CRITICAL,
    'ERROR' : ERROR,
    'WARN' : WARNING,
    'WARNING' : WARNING,
    'INFO' : INFO,
    'DEBUG' : DEBUG,
    'NOTSET' : NOTSET,
}

avec plus loin ceci :

def getLevelName(level):
    """
    Return the textual representation of logging level 'level'.

    If the level is one of the predefined levels (CRITICAL, ERROR, WARNING,
    INFO, DEBUG) then you get the corresponding string. If you have
    associated levels with names using addLevelName then the name you have
    associated with 'level' is returned.

    If a numeric value corresponding to one of the defined levels is passed
    in, the corresponding string representation is returned.

    Otherwise, the string "Level %s" % level is returned.
    """
    return _levelNames.get(level, ("Level %s" % level))

def addLevelName(level, levelName):
    """
    Associate 'levelName' with 'level'.

    This is used when converting levels to text during message formatting.
    """
    _acquireLock()
    try:    #unlikely to cause an exception, but you never know...
        _levelNames[level] = levelName
        _levelNames[levelName] = level
    finally:
        _releaseLock()

Je trouve ça moche et inefficace. Voici donc un exemple précis ou les symboles simplifient la vie et la clarté. Et c'est à cause de ce genre de détails que je préfère Ruby à Python.

Bon, voilà un autre exemple que j'a&i eu à traiter il y a peu :

J'utilise le module logging.

Je veux parser dans 4 fichiers différents les messages de type INFO, WARNING, ERROR, et DEBUG.

Je veux nommer mes fichiers monprog-.log avec "level" correspondant à info, warning, error ou debug.

En ruby, la façon générale de faire est de définir un symbole :ERROR :WARNING :INFO et :DEBUG

J'aurais donc un truc du genre (si les symboles existaient comme en Ruby):

mylogger=logging.getLogger(name)

for i in (:ERROR, :WARNING, :INFO, :DEBUG) :
  FILENAME="monprog"+'-'+(i.to_str()).lower()+".log"

  h=logging.handlers.RotatingFileHandler(
            FILENAME, backupCount=5)
  h.doRollover()
  h.setLevel(i)
  mylogger.addHandler(ch)

Or actuellement, les levels INFO, WARNING, DEBUG et ERROR soint implémentés ainsi :

ERROR = 40
WARNING = 30
INFO = 20
DEBUG = 10

Comment puis-je donc faire le même genre de chose sans utiliser un dictionnaire ?

Je viens de réesayer, et ça marche. Je crois que j'ai pris un espace en trop lors du copier/coller. Mais ce que tu fais là me semble bizarre : lorsque j'ai essayer de le transposer à un vrai exemple dans un script (comme celui plus haut), j'ai obtenu une erreur indiquant que l'objet str n'avait pas de méthode foo.

Chez moi ça n'a pas marché (voir mon autre commentaire un peu plus haut). Mais je viens de voir que je suis en Python 2.7, pas en Python3. Peut-être pour ça ?

Bon, j'ai testé, ça marche, mais il y a une ou deux coquilles dans le code fourni à l'origine qui m'ont induit en erreur : le premier paramètre ne doit pas être une chaine :

#!/usr/bin/python

class MyObject:

    def __init__(self):
        self.a=20
    def method1(self):
        return 10

O=MyObject()

print(O.method1())

attr=" a "
method = "method1"
obj = " MyObject "
print (getattr(O, "a"))
print (getattr(O, method)())

à l'exécution$ ./toto.py

10
20
10

J'essaierai de retrouver mon exemple car il me semble que c'était un peu plus subtil. Celà dit merci pour l'astuce.

As-tu essayé le code donné plus haut ?

D'après la doc python :

getattr(object, name[, default])

Return the value of the named attribute of object. name must be a string. If the string is the name of one of the object’s attributes, the result is the value of that attribute. For example, getattr(x, 'foobar') is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided, otherwise AttributeError is raised.

Il semble (mais je peux me tromper) que ceci ne concerne que les attributs et non les méthodes …

http://www-etud.iro.umontreal.ca/~dift2035/e2009/cours/introduction_a_ruby_reduite_v0.3.pdf

Où sont utilisés les symboles ?
[ ... ]
Noms de méthodes 
Pour faire référence au nom d’une méthode, on peut
utiliser un symbole Car en définissant une méthode, un symbole est créé
et porte le même nom que la méthode en question

L'un des intérêts en ruby est qu'on peut appeler des méthodes dynamiquement sans faire appel à Eval : c'est dans un cas de ce genre que ceux-ci m'ont manqués.

https://www.ruby-lang.org/fr/documentation/ruby-from-other-languages/
http://fr.wikiversity.org/wiki/Ruby/Symboles
http://www.journaldunet.com/developpeur/tutoriel/ruby/061019-ruby-symboles.shtml