[2piF]

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

#!/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

[dwblas]

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.

[2piF]

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:

#!/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)

[MrFujin]

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)?