PyQt Lab’ : Mini-PC : pcDuino : Le résultat de 6 mesures analogiques est affiché dans une interface graphique avec 6 widgets afficheurs LCD

Le pcDuino est un mini-PC qui offre une variété de fonctionnalités et de possibilités. Avec PyQt Lab, il est possible de créer une interface graphique pour afficher le résultat de 6 mesures analogiques à l’aide de 6 widgets afficheurs LCD. Cette fonctionnalité permet aux utilisateurs de visualiser leurs données de manière intuitive et facile à comprendre. Grâce à PyQt Lab, le pcDuino peut être utilisé pour des applications variées, telles que la surveillance et le contrôle à distance, la visualisation des données et le développement d’applications. Dans cet article, nous allons examiner en détail comment PyQt Lab peut être utilisé pour afficher le résultat de 6 mesures analogiques sur le pcDuino.

PyQt Lab’ : Mini-PC : pcDuino : Le résultat de 6 mesures analogiques est affiché dans une interface graphique avec 6 widgets afficheurs LCD

Par X. HINAULT – Juin 2013 – Testé sur pcDuino et poste fixe + Arduino. Incompatible RaspberryPi (pas de broches analogiques)

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

On voit très bien ici que sur le pcDuino, les voies A0 et A1 sont 6 bits (0 à 63) et les voies A2 à A5 sont 12 bits (0 à 4095).

Ce que l’on va faire ici

Dans ce programme PyQt, je montre comment afficher 6 mesures analogiques dans 6 afficheurs LCD graphiques 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 mesure à l’aide d’une simple instruction analogRead() intégrée directement au sein du code PyQt !!
Les bases de la réalisation d’interface graphique de visualisation de mesure, en local ou à distance par le réseau, sont posées ! Il sera assez facile d’utiliser cette interface pour visualiser jusqu’à… 6 dispositifs (le pcDuino dispose de 6 broches analogiques) indépendamment les uns des autres ou couplées !

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

pcDuino avec système Lubuntu opérationnel. Voir si besoin la page d’accueil du pcDuino
Langage Python (2.7) et l’éditeur Geany installés. Voir si besoin : S’installer pour programmer le pcDUino en Python et intro au langage Python PDF
pyqt4.x installé. Voir si besoin : Python+Qt : Premiers pas : Comment développez ses propres interfaces graphiques sur le pcDuino ? PDF
ma librairie pyDuino fournissant les fonctions Arduino pour Python. Installer la librairie avec la commande suivante à saisir dans un terminal :

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

[$[Get Code]]

Téléchargement des codes

L’archive avec les codes est disponible ici : http://ubuntuone.com/3weiFVRftDX8N0onLvO5rn
A télécharger en ligne de commande avec :

$ cd scripts_pyqt
$ wget -4 -N –content-disposition http://ubuntuone.com/3weiFVRftDX8N0onLvO5rn

[$[Get Code]]

Une fois l’archive obtenue, l’extraire graphiquement ou avec la commande :

$ tar -xvzf archive.tar.gz

[$[Get Code]]

Matériel nécessaire

une plaque d’essai pour montage sans soudures,

des straps,

une résistance variable, ( on pourra en utiliser jusqu’à 6)

Instructions de montage

Connecter la sortie variable de la résistance variable à une des broches analogique de A0 à A6, la deux autres broches de la résistance variable étant connectées entre le 0V et le 3.3V.

Le montage à réaliser

Note : On ne représente ici qu’une seule résistance variable, mais on pourra en utiliser jusqu’à 6 simultanément.

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 Sep 14 11:03:17 2013
# 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(353, 192)
self.lcdNumber_A3 = QtGui.QLCDNumber(Form)
self.lcdNumber_A3.setGeometry(QtCore.QRect(200, 30, 136, 40))
self.lcdNumber_A3.setStyleSheet(_fromUtf8(« background-color: rgb(170, 255, 127);\n«
« color: rgb(85, 170, 0); »))
self.lcdNumber_A3.setFrameShape(QtGui.QFrame.Box)
self.lcdNumber_A3.setFrameShadow(QtGui.QFrame.Sunken)
self.lcdNumber_A3.setSegmentStyle(QtGui.QLCDNumber.Filled)
self.lcdNumber_A3.setObjectName(_fromUtf8(« lcdNumber_A3 »))
self.labelVoie_A2 = QtGui.QLabel(Form)
self.labelVoie_A2.setGeometry(QtCore.QRect(20, 125, 121, 16))
self.labelVoie_A2.setObjectName(_fromUtf8(« labelVoie_A2 »))
self.labelVoie_A3 = QtGui.QLabel(Form)
self.labelVoie_A3.setGeometry(QtCore.QRect(200, 15, 121, 16))
self.labelVoie_A3.setObjectName(_fromUtf8(« labelVoie_A3 »))
self.labelVoie_A5 = QtGui.QLabel(Form)
self.labelVoie_A5.setGeometry(QtCore.QRect(200, 125, 121, 16))
self.labelVoie_A5.setObjectName(_fromUtf8(« labelVoie_A5 »))
self.lcdNumber_A0 = QtGui.QLCDNumber(Form)
self.lcdNumber_A0.setGeometry(QtCore.QRect(20, 30, 136, 40))
self.lcdNumber_A0.setStyleSheet(_fromUtf8(« background-color: rgb(170, 255, 127);\n«
« color: rgb(85, 170, 0); »))
self.lcdNumber_A0.setFrameShape(QtGui.QFrame.Box)
self.lcdNumber_A0.setFrameShadow(QtGui.QFrame.Sunken)
self.lcdNumber_A0.setSegmentStyle(QtGui.QLCDNumber.Filled)
self.lcdNumber_A0.setObjectName(_fromUtf8(« lcdNumber_A0 »))
self.lcdNumber_A2 = QtGui.QLCDNumber(Form)
self.lcdNumber_A2.setGeometry(QtCore.QRect(20, 140, 136, 40))
self.lcdNumber_A2.setStyleSheet(_fromUtf8(« background-color: rgb(170, 255, 127);\n«
« color: rgb(85, 170, 0); »))
self.lcdNumber_A2.setFrameShape(QtGui.QFrame.Box)
self.lcdNumber_A2.setFrameShadow(QtGui.QFrame.Sunken)
self.lcdNumber_A2.setSegmentStyle(QtGui.QLCDNumber.Filled)
self.lcdNumber_A2.setObjectName(_fromUtf8(« lcdNumber_A2 »))
self.lcdNumber_A1 = QtGui.QLCDNumber(Form)
self.lcdNumber_A1.setGeometry(QtCore.QRect(20, 85, 136, 40))
self.lcdNumber_A1.setStyleSheet(_fromUtf8(« background-color: rgb(170, 255, 127);\n«
« color: rgb(85, 170, 0); »))
self.lcdNumber_A1.setFrameShape(QtGui.QFrame.Box)
self.lcdNumber_A1.setFrameShadow(QtGui.QFrame.Sunken)
self.lcdNumber_A1.setSegmentStyle(QtGui.QLCDNumber.Filled)
self.lcdNumber_A1.setObjectName(_fromUtf8(« lcdNumber_A1 »))
self.labelVoie_A0 = QtGui.QLabel(Form)
self.labelVoie_A0.setGeometry(QtCore.QRect(20, 15, 121, 16))
self.labelVoie_A0.setObjectName(_fromUtf8(« labelVoie_A0 »))
self.lcdNumber_A5 = QtGui.QLCDNumber(Form)
self.lcdNumber_A5.setGeometry(QtCore.QRect(200, 140, 136, 40))
self.lcdNumber_A5.setStyleSheet(_fromUtf8(« background-color: rgb(170, 255, 127);\n«
« color: rgb(85, 170, 0); »))
self.lcdNumber_A5.setFrameShape(QtGui.QFrame.Box)
self.lcdNumber_A5.setFrameShadow(QtGui.QFrame.Sunken)
self.lcdNumber_A5.setSegmentStyle(QtGui.QLCDNumber.Filled)
self.lcdNumber_A5.setObjectName(_fromUtf8(« lcdNumber_A5 »))
self.lcdNumber_A4 = QtGui.QLCDNumber(Form)
self.lcdNumber_A4.setGeometry(QtCore.QRect(200, 85, 136, 40))
self.lcdNumber_A4.setStyleSheet(_fromUtf8(« background-color: rgb(170, 255, 127);\n«
« color: rgb(85, 170, 0); »))
self.lcdNumber_A4.setFrameShape(QtGui.QFrame.Box)
self.lcdNumber_A4.setFrameShadow(QtGui.QFrame.Sunken)
self.lcdNumber_A4.setSegmentStyle(QtGui.QLCDNumber.Filled)
self.lcdNumber_A4.setObjectName(_fromUtf8(« lcdNumber_A4 »))
self.labelVoie_A4 = QtGui.QLabel(Form)
self.labelVoie_A4.setGeometry(QtCore.QRect(200, 70, 121, 16))
self.labelVoie_A4.setObjectName(_fromUtf8(« labelVoie_A4 »))
self.labelVoie_A1 = QtGui.QLabel(Form)
self.labelVoie_A1.setGeometry(QtCore.QRect(20, 70, 121, 16))
self.labelVoie_A1.setObjectName(_fromUtf8(« labelVoie_A1 »))

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

def retranslateUi(self, Form):
Form.setWindowTitle(QtGui.QApplication.translate(« Form », « PyQt + Pyduino : analogRead 6 voies », None, QtGui.QApplication.UnicodeUTF8))
self.labelVoie_A2.setText(QtGui.QApplication.translate(« Form », « Voie analogique A2 : », None, QtGui.QApplication.UnicodeUTF8))
self.labelVoie_A3.setText(QtGui.QApplication.translate(« Form », « Voie analogique A3 : », None, QtGui.QApplication.UnicodeUTF8))
self.labelVoie_A5.setText(QtGui.QApplication.translate(« Form », « Voie analogique A5 : », None, QtGui.QApplication.UnicodeUTF8))
self.labelVoie_A0.setText(QtGui.QApplication.translate(« Form », « Voie analogique A0 : », None, QtGui.QApplication.UnicodeUTF8))
self.labelVoie_A4.setText(QtGui.QApplication.translate(« Form », « Voie analogique A4 : », None, QtGui.QApplication.UnicodeUTF8))
self.labelVoie_A1.setText(QtGui.QApplication.translate(« Form », « Voie analogique A1 : », 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_())

[$[Get Code]]

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 *

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

setDebug(True) # active message debug Pyduino

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
self.timer=QTimer() # déclare un timer Qt
self.timer.start(200) # 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 des widgets LCD
self.lcdNumber_A0.display(0000) # affiche la valeur dans le LCD

# 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(« —–« )
self.lcdNumber_A0.display(analogRead(A0)) # affiche la valeur de la mesure sur A0 dans le LCD
self.lcdNumber_A1.display(analogRead(A1)) # affiche la valeur de la mesure sur A1 dans le LCD
self.lcdNumber_A2.display(analogRead(A2)) # affiche la valeur de la mesure sur A2 dans le LCD
self.lcdNumber_A3.display(analogRead(A3)) # affiche la valeur de la mesure sur A3 dans le LCD
self.lcdNumber_A4.display(analogRead(A4)) # affiche la valeur de la mesure sur A4 dans le LCD
self.lcdNumber_A5.display(analogRead(A5)) # affiche la valeur de la mesure sur A5 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

[$[Get Code]]

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 les 6 afficheurs LCD : faîtes varier la valeur de la résistance variable pour voir la valeur numérique s’actualiser en temps réel !