#1
  1. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Apr 2017
    Posts
    2
    Rep Power
    0

    acquirement 20Hz electrical signal


    Hello, I expose my problem: I want to acquire a signal various frequency (alternating sinusoidal 0.2mV alternative with the help of a program in python.) I need a sampling frequency 8 times greater. I'm am on a pcduino card.
    For 1Hz the signal is correct, but for 20Hz is doesnt work.
    I think is a sample problem.
    Have you have idea, or solution.
    Thanks





    Code:
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    
    # 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
  2. #2
  3. No Profile Picture
    Contributing User
    Devshed Novice (500 - 999 posts)

    Join Date
    May 2009
    Posts
    646
    Rep Power
    38
    To start, write a separate program without the GUI and np, just printing the values received to see that it is working properly. One possibility is that the values are literally "off the chart" of the GUI. We can help more if we know where to look, i.e. the data is/is not being received.
  4. #3
  5. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Apr 2017
    Posts
    2
    Rep Power
    0

    new program


    I try a different program, and it's work.
    I receive the electrical signal at 20Hz et my data are correct. I can drow the same signal. I took a sample frequency at 200Hz
    But, the problem is, I don't have the same number of value in my Terminal and in my file.txt.
    And don't know why. Thanks
    This is my new code:



    Code:
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    from pyduino import * # importe les fonctions Arduino pour Python
    import numpy as np
    import time
    import signal
    import time
    import datetime
    
    
    def handler(signum, frame):
    #frame : moyen de connaitre l'état d'exécution
    #avant que le gestionnaire
    #de signal a été déclenché
    #gestionnaire e signal peut
    #lire des états à l'intèrieur du champ d'application qui a été
    #exécuté avant que le gestionnaire de signal peut lire
    
    ##ouverture et écriture du fichier##
                    try:
                            print" "
    
                    except IOError as e:
                                    print"I/O error({0}): {1}".format(e.errno,e.strerror)
    
    signal.signal(signal.SIGALRM, handler)
    
    signal.setitimer(signal.ITIMER_REAL, 0.005, 0.005) #setitimer:
    (qui,seconde[intervallee]
    
    #ITIMER_REAL: décrémente l'intervalle en temps réel et fournit un
    signal d'alarme
    
    ##Durée de la mesure##
            ##temps échantillonnage pour 20Hz
    
    
    f=open("/home/ubuntu/data/text/TensionsA2.txt","w") # ouverture du
    fichier avec écraserment des données , si fichier non existant il est
    crée
    temps=6
    start = time.time()
    while (time.time() - start) <= (temps):
    
                    mesure=analogRead(A2)*3.3/4095.0 #lecture sur le pin Analogique
                    time.sleep(0.005)
                    f.write(str(mesure)+"\n")
                    print mesure
                    print "nombre de valeur"+ "  "+str(temps/0.005)

    Comments on this post

    • Will-O-The-Wisp agrees : I've added [code] tags to your post. In the future, please wrap [code] and [slashcode] where the "slash" is replaced with "/" around your code in the future! Thanks!
  6. #4
  7. Lord of the Dance
    Devshed Specialist (4000 - 4499 posts)

    Join Date
    Oct 2003
    Posts
    4,109
    Rep Power
    2010
    You forgot the code tag.

    Can you be more detailed on what you in Terminal? in file? And how is this different from what you expect to receive (what you are sending)?

IMN logo majestic logo threadwatch logo seochat tools logo