View difference between Paste ID: w3ZR34gr and VeKwvQDR

 #!/usr/bin/python2
 # -*- coding: utf-8 -*-
 
 import Tkinter, random, time
-import socket, sys, serial
+import socket, sys
 import random, time, threading
 from struct import unpack
 
 
 #########################    PARAMÈTRES    #####################################
 
 # Dimmensions du graphique en pixel
 canvas_height = 600
 canvas_width = 800
 
 # Valeurs min et max de l'axe des ordonnées
 val_min = -200
 val_max = 200
 
 # Temps de raffraichissement de l'écran en secondes
 refresh = 0.01
 
 # Couleurs des graphes
 colors = ["#00FF00", "#FF0000", "#0000FF", "#FFFF00", "#00FFFF", "#FF00FF"]
 
 # Entrées, valeurs acceptées :
 #  -> stdin  : récupération des valeurs via l'entrée standard
 #       utilisation ./script_qui_affiche_mes_données_ligne_par_ligne | ./real_time_plot.py
 #  -> random : valeurs aléatoires, pour les tests
 #  -> serial : port série
 entree = "random"
 
 if entree == "serial":
     import serial
     # Configuration du port série
     port = '/dev/pts/13' # sous Windows : COM13
     baudrate = 9600
     # Format binaire des données
     # définit par http://docs.python.org/2/library/struct.html#format-characters
     format = "Ihh"
     # taille en octets du format,
     #    exemple, si format = "hh" (2 shorts, 2 octets chacun), alors taille_format = 4
     taille_format = 8
 
 
 ############################    FIN PARAMÈTRES     #############################
 
 def convert(val):
     return canvas_height - canvas_height*float(val-val_min)/(val_max-val_min)
 
 def convert2(val):
     return (canvas_height - val)/512.0*(val_max-val_min) + val_min
 
 
 
 class App:
 
     def white(self):
         self.lines=[]
         self.lastpos=[]
 
         self.c.create_rectangle(0, 0, canvas_width, canvas_height, fill="black")
 
         self.gradations()
 
     def gradations(self):
         # Vertical gradations
         for y in range(0,canvas_height,32):
                 self.c.create_line(0, y, canvas_width, y, fill="#333333",dash=(4, 4))
                 self.c.create_text(5, y-10, fill="#999999", text=str(convert2(y)), anchor="w")
         # Horizontal gradations
         for x in range(100,canvas_width,100):
                 self.c.create_line(x, 0, x, canvas_height, fill="#333333",dash=(4, 4))
                 self.c.create_text(x+3, canvas_height-22, fill="#999999", text=str(x), anchor="w")
 
         self.lineRedraw=self.c.create_line(0, canvas_width, 0, 0, fill="red")
 
         self.lines1text=self.c.create_text(canvas_width-150, 10, fill="#00FF00", text=str("TEST"), anchor="e")
 
     def addPoint(self,vals):
         for i in range(len(vals)):
             val = vals[i]
             if len(self.data) <= i:
                 self.data.append([0]*canvas_width)
                 self.lastpos.append(0)
                 self.lines.append([])
                 for x in range(canvas_width):
                     self.lines[i].append(self.c.create_line(x, 0, x, 0, fill=colors[i%len(colors)]))
 
             self.data[i][self.xpos] = val
             # Display the average value
             #~ self.line1avg+=val
             #~ if self.xpos%10==0:
                     #~ self.c.itemconfig(self.lines1text,text="Average: "+str(self.line1avg/10.0))
                     #~ self.line1avg=0
             if self.xpos>0:
                 self.c.coords(self.lines[i][self.xpos],(self.xpos-1,self.lastpos[i],self.xpos,convert(val)))
             if self.xpos<canvas_width:
                 self.c.coords(self.lineRedraw,(self.xpos+1,0,self.xpos+1,canvas_width))
             self.lastpos[i]=convert(val)
         self.xpos+=1
         if self.xpos==canvas_width:
                 self.xpos=0
                 self.totalPoints+=canvas_width
                 print "FPS:",self.totalPoints/(time.time()-self.timeStart)
         t.update()
 
     def __init__(self, t):
         self.xpos=0
         self.line1avg=0
         self.data = []
         self.c = Tkinter.Canvas(t, width=canvas_width, height=canvas_height)
         self.c.pack()
         self.totalPoints=0
         self.white()
         self.timeStart=time.time()
 
 
 
 
 class ValuesReaderSerial:
     def __init__(self):
         self.ser = serial.Serial(
             port=port,
             baudrate=baudrate,
             parity=serial.PARITY_ODD,
             stopbits=serial.STOPBITS_TWO,
             bytesize=serial.SEVENBITS
         )
         if not self.ser.isOpen():
             self.ser.open()
         print "Serial port open"
 
     def get(self):
         if self.ser.inWaiting() > 0:
             buff = self.ser.read(taille_format);
             values = unpack(format, buff)
             print(values)
             return values
         else:
              return None
 
 
 class ValuesReaderRandom:
     def __init__(self):
         self.val1 = 20
         self.val2 = 30
         self.val3 = 40
     def get(self):
         self.val1 += random.randint(-1,1)
         self.val2 += random.randint(-3,3)
         self.val3 += random.randint(-2,2)
         return (self.val1, self.val2, self.val3)
 
 
 class ValuesReaderStdIn:
     def get(self):
         line = sys.stdin.readline()
         vals = map(float, line.split())
         return vals
 
 
 
 
 
 if entree == "random":
     values = ValuesReaderRandom()
 elif entree == "stdin":
     values = ValuesReaderStdIn()
 elif entree == "serial":
     values = ValuesReaderSerial()
 else:
     RuntimeError("entree invalide")
 
 
 t = Tkinter.Tk()
 a = App(t)
 
 # Boucle principale
 while True:
     points = values.get()
     if points != None:
         print points
         a.addPoint(points)
     else:
         t.update()
     time.sleep(refresh)