IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Calcul scientifique Python Discussion :

Acquisition de signaux électriques sur Python


Sujet :

Calcul scientifique Python

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2017
    Messages
    10
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Santé

    Informations forums :
    Inscription : Avril 2017
    Messages : 10
    Points : 3
    Points
    3
    Par défaut Acquisition de signaux électriques sur Python
    Bonjour, je expose mon problème: je veux acquérir un signal diverse fréquence (alternatif sinusoidale 0,2mV alternatif à l'aide d'un programme en python. Il me faut une fréquence d'échantillonnage 8 fois plus grande. j'arrive à envoyer les données dans un fichier texte et à faire un graphique. (je fais appel un autre programme pour afficher les axes).
    Mais je n'arrive pas à avoir la fréquence voulu, par exemple du 20Hz et aussi je voudrai remplacer if__name__=="__main__" pour que le programme s'arrête.
    J'ai testé différent programme avec des timers mais sans résultat non plus.
    Je vous ai mis mon code et le graphe obtenue. Si vous avez des idées ou une aide à m'apporter serai la bien venu. Merci




    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
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    # par X. HINAULT - Mai 2013 - Tous droits réservés
    # modules a importer
     
    from PyQt4.QtGui import *
    from PyQt4.QtCore import *  # inclut QTimer..
    import time
     
    import os,sys
     
    import pyqtgraph as pg # pour accès à certaines constantes pyqtgraph,
    widget, etc...
     
    import numpy as np # math et tableaux
     
    from pyduino import * # importe Pyduino
     
    from tuto_pyqt_pyduino_pyqtgraph_oscillo_simple import * # fichier
    obtenu à partir QtDesigner et pyuic4
     
    # +/- variables et objets globaux
     
    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
     
                                    # --- Variables de classe
                                    self.points=None # déclaration initiale
                                    self.compt=0 # variable comptage
                                    self.nombreValeurs=100
                                    self.framerate=10# nombre d'image par secondes (rafraîchissement
    de l'affichage)
     
     
                                    # --- Paramétrage des widgets de l'interface GUI si nécessaire ---
     
                                    # --- Connexions entre signaux des widgets et fonctions
                                    # connecte chaque signal utilisé des objets à l'appel de la fonction voulue
     
                                    # --- Code actif initial  ---
     
                                    #-- initialise le graphique pyqtgraph --
                                    # l'objet self.graph correspond au plotWidget créé dans QtDesigner
     
                                    # aspect fond /axes
                                    #self.graph.hideAxis('left') # masque axes - ‘left’, ‘bottom’,
    ‘right’, or ‘top’
                                    self.graph.setBackgroundBrush(QBrush(QColor(Qt.white))) # la
    classe PlotWidget est un GraphicsWidget qui est un QGraphics View
                                    self.graph.showGrid(x=True, y=True)  # affiche la grille
                                    self.graph.getAxis('bottom').setPen(pg.mkPen(0,0,255)) # couleur
    de l'axe + grille
                                    self.graph.getAxis('left').setPen(pg.mkPen(255,0,0)) # couleur de
    l'axe + grille
     
                                    # légende des axes
                                    labelStyle = {'color': '#00F', 'font-size': '10pt'} # propriétés
    CSS à utiliser pour le label
                                    self.graph.getAxis('bottom').setLabel('temps', units='1s=10',
    **labelStyle) # label de l'axe
                                    self.graph.getAxis('left').setLabel('tension', units='V',
    **labelStyle) # label de l'axe
     
                                    # adaptation échelle axes
                                    # axe X et Y sont autoscale par défaut
                                    self.graph.enableAutoRange(axis=pg.ViewBox.YAxis, enable=False) #
    fonction plotItem : désactive autoscale Y
     
                                    self.minY=0
                                    self.maxY=1
                                    self.graph.setYRange(self.minY,self.maxY) # fonction plotItem :
    fixe échelle des Y
     
                                    self.minX=0
                                    self.maxX=self.nombreValeurs
                                    self.graph.setXRange(self.minX,self.maxX) # fonction plotItem :
    fixe échelle des X
     
                                    # interactivité
                                    #self.graph.setInteractive(False) # fonction QGraphics View : pour
    inactiver interaction souris
                                    self.graph.getViewBox().setMouseMode(pg.ViewBox.RectMode)  #
    fonction ViewBox pas accessible depuis PlotWidget : fixe selection par
    zone
                                    self.graph.setMouseEnabled(x=False, y=True) # désactive interactivité axe X
     
                                    #-- initialise données --
                                    #-- définition des x
                                    self.x = np.arange(0.0, self.nombreValeurs+1, 1.0) # crée un
    vecteur de n valeurs à intervalle régulier pour les x
                                    print(self.x) # debug - affiche les valeurs x
     
                                    #-- calcul des y : courbe y=f(x)
                                    self.y=np.zeros(self.nombreValeurs+1)# crée un tableau de valeur y
    basé sur x - courbe y=sin(x)
                                    #self.y= 500+(np.random.normal(0,1,size=self.nombreValeurs+1)
    *250) # génére une série de n valeurs aléatoires
     
                                    print(self.y) # debug - affiche les valeurs y
     
                                    #-- affichage de la courbe --
                                    self.courbe=self.graph.plot(self.x,self.y, pen=(0,0,22)) # avec couleur
     
                    # -- Activation d'un Timer pour MAJ graphique - fixe le fps
    d'affichage en fait --
                                    self.timerRefreshPlot=QTimer() # déclare un timer Qt
                                    self.connect(self.timerRefreshPlot, SIGNAL("timeout()"),
    self.refreshPlot) # connecte le signal timeOut de l'objet timer à
    l'appel de la fonction voulue
                                    self.timerRefreshPlot.start(int(1000/self.framerate)) # lance le
    timer - mettre délai assez court pour fps élevé
     
                    # --- les fonctions appelées, utilisées par les signaux des widgets ---
     
     
                    # --- les fonctions appelées, utilisées par les signaux hors widgets ---
     
                    #----- fonction de gestion du signal timeout du QTimer
                    def refreshPlot(self): # fonction appelée lors de la survenue d'un
    évènement Timer - nom fonction indiférrent
                                    global f
                                    print ("MAJ graph : valeur = "), # debug
                                    f=open("/home/ubuntu/data/text/TensionsA2.txt","a") # ouverture du
    fichier avec écraserment des données , si fichier non existant il est
    crée
     
                                    #value=500
                                    value=analogRead(A2)*3.3/4095.0
     
                                    print value , "V"
                                    f.write(str(value)+"\n")
                                    f.close()
     
                                    if self.compt==0: # premier passage
     
                                                    self.points= np.array([[self.compt,value]]) # tableau à 2
    dimensions - ici 1er points
                                                    self.x=self.points[:,0] # la première colonne = les x
                                                    self.y=self.points[:,1] # la deuxième colonne = les y
                                                    self.compt=self.compt+1 # incrémente compt
                                                    print "nombre de valeurs", self.compt
     
     
                                    elif self.compt<=self.nombreValeurs: # on remplit le tableau de
    point une première fois
                                                            newY=value
                                                            #newY=self.compt # x=y - debug
                                                            self.points=np.append(self.points,[[self.compt,newY]],axis=0)#
    ajouter un point au tableau
                                                            self.x=self.points[:,0] # la première colonne = les x
                                                            self.y=self.points[:,1] # la deuxième colonne = les y
                                                            self.compt=self.compt+1 # incrémente compt
                                                            print "nombre de valeurs", self.compt
     
     
                                    #else:
                                                    #self.points=roll(self.points,1, axis=1) # décale les éléments y
    de 1 - fonctin numpy
                                                    #self.x=self.points[:,0] # la première colonne = les x - existe déjà
                                                    #self.y=self.points[:,1] # la deuxième colonne = les y - existe déjà
     
                                                    #self.y=roll(self.y,1) # décale les éléments y de 1 - fonctin
    numpy - les x ne bougent pas..
                                                    #self.y=np.roll(self.y,-1) # décale les éléments y de 1 -
    fonctin numpy - les x ne bougent pas..
     
                                                    #self.y[self.Xmax]=self.y[self.Xmax-1]/2 # nouvelle valeur en
    dernière position
                                                    #self.y[self.nombreValeurs]=value # nouvelle valeur en dernière position
     
                                    #-- initialise la courbe --
                                    self.courbe.setData(self.x,self.y) # initialisation valeurs courbe
     
            # --- fonctions de classes autres---
     
     
     
    # -- Autres Classes utiles --
     
    # -- Classe principale (lancement)  --
     
    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
    Images attachées Images attachées  

Discussions similaires

  1. Application reseau de neurone sur python!
    Par tnouss dans le forum Calcul scientifique
    Réponses: 3
    Dernier message: 15/04/2007, 21h18
  2. Boucles sur python
    Par Spitfire378 dans le forum Général Python
    Réponses: 10
    Dernier message: 08/04/2007, 21h46
  3. Comment obtenir une adresse mac sur python
    Par Wael Maaoui dans le forum Réseau/Web
    Réponses: 4
    Dernier message: 19/02/2007, 14h52
  4. Acquisition de signaux
    Par tiluz dans le forum Langage
    Réponses: 2
    Dernier message: 20/09/2006, 14h00

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo