View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

PYQTLAB

PyQt Lab' : Mini-PC : pcDuino : L'appui sur un bouton fait défiler un compteur dans une interface graphique avec un widget afficheur LCD (pompe a essence)


Par X. HINAULT - Juin 2013

Capture du bureau du pcDuino en accès distant par VNC, webcam branchée !

Avec 30 lectures par seconde et accès VNC en place, l'usage CPU n'est que de 1 à 2 % avec ce code en l'absence d'appui (30% lors appui) et cette interface graphique !!

Ce que l'on va faire ici

  • Dans ce programme PyQt, je montre comment lire l'état d'un bouton poussoirpour incrémenter une variable et l'afficher avec un afficheur LCD graphique au sein d'une interface PyQt.
  • La clé consiste ici à utiliser un QTimer, objet PyQt permettant d'appeler une fonction à intervalle régulier : c'est à ce niveau que l'on réalisera la lecture de l'état du bouton poussoir avec digitalRead() intégrée directement au sein du code PyQt !!
  • Les bases de la réalisation d'interface graphique interagissant avec des capteurs ON/OFF mécaniques, en local ou à distance par le réseau, sont posées ! Il sera assez facile de transposer cette interface pour visualiser jusqu'à... 18 dispositifs ON/OFF (le pcDuino dispose de 18 broches numériques) indépendamment les uns des autres.

ATTENTION : Ce code est à exécuter sur un mini-PC (prévu pour le pcDuino, aussi compatible RaspberryPi)

Une nouvelle fois, tout l'intérêt de ce programme est de montrer avec quelle simplicité il est facile de coupler l'utilisation de la librairie Pyduino avec une interface PyQt : l'accès aux fonctions Pyduino se fait directement dans le code PyQt !! Une chose tout simplement impossible à partir de l'IDE Arduino ! A partir du moment où il est possible d'utiliser les instructions Pyduino au sein même d'un code d'interface graphique, je vous laisse imaginer la suite...

  • Truc d'utilisation : En accédant au mini-PC par accès distant VNC via une tablette graphique ou un smartphone, vous contrôlez la LED à distance et sans fil ! Imaginez que ce ne soit pas une LED... mais tout autre dispositif de votre choix : çà donne des idées non ?

Pré-requis

sudo wget -4 -N https://raw.github.com/sensor56/pyDuino/master/pcduino/pyduino.py /usr/lib/python2.7/dist-packages

Téléchargement des codes

Matériel nécessaire

  • une plaque d'essai pour montage sans soudures,
  • des straps,
  • un bouton poussoir pour CI,

Instructions de montage

  • Connecter un bouton poussoir entre la broche 2 (configurée en entrée avec rappel au plus) et le 0V

Le montage à réaliser

Le fichier d'interface *.py

  • Fichier obtenu automatiquement avec l'utilitaire pyuic4 à partir du fichier *.ui créé avec QtDesigner :

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file
# Created: Sat Dec 22 14:49:08 2012
#      by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    _fromUtf8 = lambda s: s

class Ui_Form(object):
    def setupUi(self, Form):
        Form.setObjectName(_fromUtf8("Form"))
        Form.resize(307, 128)
        self.lcdNumber = QtGui.QLCDNumber(Form)
        self.lcdNumber.setGeometry(QtCore.QRect(85, 25, 141, 66))
        self.lcdNumber.setStyleSheet(_fromUtf8("background-color: rgb(170, 255, 127);\n"
"color: rgb(85, 170, 0);"))
        self.lcdNumber.setFrameShape(QtGui.QFrame.Box)
        self.lcdNumber.setFrameShadow(QtGui.QFrame.Raised)
        self.lcdNumber.setSmallDecimalPoint(False)
        self.lcdNumber.setSegmentStyle(QtGui.QLCDNumber.Flat)
        self.lcdNumber.setObjectName(_fromUtf8("lcdNumber"))

        self.retranslateUi(Form)
        QtCore.QMetaObject.connectSlotsByName(Form)

    def retranslateUi(self, Form):
        Form.setWindowTitle(QtGui.QApplication.translate("Form", "PyQt : Timer + widget LCD", None, QtGui.QApplication.UnicodeUTF8))


if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    Form = QtGui.QWidget()
    ui = Ui_Form()
    ui.setupUi(Form)
    Form.show()
    sys.exit(app.exec_())

 

Le fichier d'application *Main.py

  • Remarquer comment les fonctions Pyduino sont directement appelées dans le code PyQt : simple et efficace !!

Le code actif nécessaire contenu dans ce fichier est simple et réduit à l'essentiel, et pourtant, il s'agit d'une interface graphique !


#!/usr/bin/python
# -*- coding: utf-8 -*-

# par X. HINAULT - nov 2012 - Tous droits réservés
# GPLv3 - www.mon-club-elec.fr

# modules a importer
from PyQt4.QtGui import *
from PyQt4.QtCore import *  # inclut QTimer..
import os,sys

from pyduino import * # importe les fonctions Arduino pour Python

from tuto_pyqt_pyduino_bases_timer_widget_lcd_digitalread_bp import * # fichier obtenu à partir QtDesigner et pyuic4

BP=2 # broche du bouton poussoir
APPUI=LOW # variable etat appui

class myApp(QWidget, Ui_Form): # la classe reçoit le Qwidget principal ET la classe définie dans test.py obtenu avec pyuic4
        def __init__(self, parent=None):
                QWidget.__init__(self) # initialise le Qwidget principal
                self.setupUi(parent) # Obligatoire

                #Ici, personnalisez vos widgets si nécessaire

                #Réalisez les connexions supplémentaires entre signaux et slots
                # aucun ici

                # code initial

                #-- initialisation du Timer => permet lecture broche BP a intervalles reguliers
                self.timer=QTimer() # déclare un timer Qt
                self.timer.start(30) # lance le timer - durée en ms
                self.connect(self.timer, SIGNAL("timeout()"), self.timerEvent) # connecte le signal timeOut de l'objet timer à l'appel de la fonction voulue
                # NB : le nom de la fonction appelée est ici timerEvent : ce nom est arbitraire et peut être ce que l'on veut...
                self.compt=0 # variable de comptage des évènements Timer

                #-- initialisation du widget LCD
                self.lcdNumber.display(0000) # affiche la valeur dans le LCD

                # initialisation broche BP
                pinMode(BP,PULLUP) # broche en entree avec rappel au plus actif

        # les fonctions appelées, utilisées par les signaux

        #-- fonction gestion survenue évènement Timer
        def timerEvent(self): # fonction appelée lors de la survenue d'un évènement Timer - nom de la fonction indiférrent
                #print("Timer") # debug
                if (digitalRead(BP)==APPUI): # si appui sur le bouton poussoir
                        self.compt=self.compt+1 # incrémente la variable comptage évènements Timer
                        self.lcdNumber.display(self.compt) # affiche la valeur de comptage dans le LCD



def main(args):
        a=QApplication(args) # crée l'objet application
        f=QWidget() # crée le QWidget racine
        c=myApp(f) # appelle la classe contenant le code de l'application
        f.show() # affiche la fenêtre QWidget
        r=a.exec_() # lance l'exécution de l'application
        return r

if __name__=="__main__": # pour rendre le code exécutable
        main(sys.argv) # appelle la fonction main
 

Utilisation

  • Les 2 fichiers suivants sont à enregistrer dans un même répertoire, l'un en nom.py et l'autre en nomMain.py.
  • Puis lancer l'application depuis Geany ou équivalent, en exécutant le fichier nomMain.py
  • Au lancement, la fenêtre graphique doit apparaître avec l'interface graphique intégrant un afficheur LCD : appuyer sur le bouton poussoir pour la valeur numérique s'incrémenter en temps réel !