Rigolinux :

Rigolinux est un logiciel libre (créé par La Boite à Physique !) permettant de piloter les oscilloscopes de la marque Rigol, disposant d'une liaison série RS232. Il fonctionne sous Linux.

Ce logiciel est dédié à l'enseignement : toute l'ergonomie a été orientée dans le but d'une vidéoprojection du logiciel au tableau :

- format 1024x768 (résolution de base d'un grand nombre de vidéoprojecteurs)

- possibilité de modifier les couleurs des courbes et du fond ainsi que l'épaisseur des courbes (en vidéoprojection on choisira une courbe plus épaisse pour la rendre bien visible du fond de la classe)

- possibilité d'afficher ou pas les réglages de sensibilités de l'oscilloscope (Pratique lors de la découverte de l'oscilloscope :

   - au bureau connecter le GBF sur l'osilloscope Rigol et projeter Rigolinux.

   - relier également le GBF à la ligne sèche de la salle de TP : tous les élèves disposent alors du même signal que le professeur.

   - en ayant masqué les réglages, demander au élèves de régler leur oscilloscope pour retrouver un affichage similaire

Ci-dessous Rigolinux (V1_03) en situation réelle :

Une nouvelle vidéo (version 1_3 du logiciel) avec commentaires qui détaille tous les réglages de base. Une deuxième est en préparation pour les fonctions avancées.

Ces vidéos sont réalisées avec les logiciels suivants :

- capture d'écran : Vokoscreen

- titrages : Inkscape

- montage vidéo : Openshot

- conversion vidéo : Winff

Chargement de la vidéo... Si vous voyez ce message, c'est que le lecteur Flash n'est pas installé.

L'onglet Mesures (version 1.1 du logiciel) :

Mesure_V1_1.png

Le logiciel n'est pas terminé, mais suffisament fonctionnel pour pouvoir être proposé sur ce site.

Les fonctions non disponibles à ce jour (11/07/2014) :

- les fonctions mathématiques (en particulier la FFT)

- le mode Roll

A venir :

- sauvegarde de l'écran au format image

Le matériel nécessaire :

Le port série du PC comme celui du Rigol est de type mâle SUBD9 :

DSCN0991.resized.JPG   DSCN0994.resized.JPG

Il faut donc un câble série SUBD9 femelle-femelle. Le protocole choisi par Rigol impose un câblage dit « droit » (fil à fil entre les deux connecteurs SUBD9)

Mais, on trouve généralement des câbles série :

- femelle-femelle mais avec un câblage croisé

- mâle-femelle avec un câblage droit ….

L'un comme l'autre ne suffisent pas.

On achètera :

- un câble série mâle-femelle (Réf Sélectronic : 14.8848)

- un adaptateur femelle-femelle (Réf Sélectronic : 14.9743) :

DSCN0996.resized.JPG 

Si on souhaite travailler avec un PC portable (généralement démuni de port série), il faut se procurer un câble adaptateur USB-série (Réf Sélectronic 14.0481-2) :

DSCN0999.resized.JPG  DSCN0998.resized.JPG

Pour réaliser la commnication série entre le logiciel et l'oscilloscope :

  - s'assurer que l'on appartient au groupe autorisé à utiliser les ports série du PC (le groupe dialout) : voir l'explication ici

  - câbler comme indiqué ci-dessus,

  - régler la vitesse de communication de l'oscilloscope sur 38400 bauds (menu Utility -> Param.E/S)

  - si l'oscilloscope est correctement détecté, le nom du modèle s'affiche au dessus de l'écran (Cf vidéo de démo ci dessus : ici c'est un DS1062CD qui est utilisé)

Pour les curieux, ci-dessous le code de la version 1.3 (pas encore bien nettoyé...) :

(Logiciel libre sous licence GPL. Copyright 2014)

Pour contacter l'auteur : vlemieux@laboiteaphysique.fr

  1. #!/usr/bin/python
  2. #-*- coding: iso-8859-15 -*-
  3.  
  4. # Copyright 2014 Vincent LE MIEUX
  5.  
  6. # Contact : vlemieux@laboiteaphysique.fr
  7.  
  8. # La version la plus récente de ce programme se trouve
  9. # sur le site de l'auteur : www.laboiteaphysique.fr
  10.  
  11. # Ce programme est un logiciel libre ; vous pouvez le redistribuer ou le modifier suivant
  12. # les termes de la GNU General Public License telle que publiée par la Free Software Foundation ;
  13. # soit la version 3 de la licence, soit (à votre gré) toute version ultérieure.
  14.  
  15. # Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE ;
  16. # sans même la garantie tacite de QUALITÉ MARCHANDE ou d'ADÉQUATION à UN BUT PARTICULIER.
  17. # Consultez la GNU General Public License pour plus de détails.
  18.  
  19. # Vous devez avoir reçu une copie de la GNU General Public License en même temps que ce programme ;
  20. # si ce n'est pas le cas, consultez <http://www.gnu.org/licenses>.
  21.  
  22. from __future__ import division
  23. from gi.repository import Gtk, Gdk, GObject
  24. import os, sys, re
  25. import serial
  26. import string
  27. import cairo
  28. from time import sleep
  29. import glob
  30. import math
  31.  
  32.  
  33. class RIGOLINUX:
  34.  
  35.  
  36. def __init__(self):
  37.  
  38. self.builder = Gtk.Builder()
  39. self.builder.add_from_file("rigolinux.glade")
  40.  
  41. #recuperation des widgets utilises par le programme :
  42. self.lb_idn = self.builder.get_object("lb_idn")
  43. self.btOuvrir = self.builder.get_object("btOuvrir")
  44. self.btFermer = self.builder.get_object("btFermer")
  45. self.btQuitter = self.builder.get_object("btQuitter")
  46. self.btRafraichir = self.builder.get_object("btRafraichir")
  47. self.comboPort = self.builder.get_object("comboPort")
  48. self.comboBauds = self.builder.get_object("comboBauds")
  49. self.bt_Manuel = self.builder.get_object("bt_Manuel")
  50. self.bt_Auto = self.builder.get_object("bt_Auto")
  51. self.tgb_RunStop = self.builder.get_object("tgb_RunStop")
  52. self.tgb_manuel = self.builder.get_object("tgb_manuel")
  53. self.bt_acq1 = self.builder.get_object("bt_acq1")
  54. self.zone_ecran = self.builder.get_object("zone_ecran")
  55. self.zone_ecran.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
  56.  
  57. self.bt_aff_ch1 = self.builder.get_object("bt_aff_ch1")
  58. self.bt_aff_ch2 = self.builder.get_object("bt_aff_ch2")
  59. self.bt_aff_bdt = self.builder.get_object("bt_aff_bdt")
  60. self.lb_CH1 = self.builder.get_object("lb_CH1")
  61. self.sw_ch1 = self.builder.get_object("sw_ch1")
  62. self.bt_plus_ch1 = self.builder.get_object("bt_plus_ch1")
  63. self.bt_moins_ch1 = self.builder.get_object("bt_moins_ch1")
  64. self.scaleCH1 = self.builder.get_object("scaleCH1")
  65. self.combo_couplage1 = self.builder.get_object("combo_couplage1")
  66. self.lb_CH2 = self.builder.get_object("lb_CH2")
  67. self.sw_ch2 = self.builder.get_object("sw_ch2")
  68. self.bt_plus_ch2 = self.builder.get_object("bt_plus_ch2")
  69. self.bt_moins_ch2 = self.builder.get_object("bt_moins_ch2")
  70. self.scaleCH2 = self.builder.get_object("scaleCH2")
  71. self.combo_couplage2 = self.builder.get_object("combo_couplage2")
  72. self.lb_BdT = self.builder.get_object("lb_BdT")
  73. self.bt_plus_BdT = self.builder.get_object("bt_plus_BdT")
  74. self.bt_moins_BdT = self.builder.get_object("bt_moins_BdT")
  75. self.scaleBdT= self.builder.get_object("scaleBdT")
  76. self.lb_decalage_horizontal = self.builder.get_object("lb_decalage_horizontal")
  77. self.sw_math = self.builder.get_object("sw_math")
  78. self.comboBdT = self.builder.get_object("comboBdT")
  79. self.lb_niveau_trigger = self.builder.get_object("lb_niveau_trigger")
  80. self.cb_afficher = self.builder.get_object("cb_afficher")
  81. self.colorbutton_fond = self.builder.get_object("colorbutton_fond")
  82. self.colorbutton1 = self.builder.get_object("colorbutton1")
  83. self.colorbutton2 = self.builder.get_object("colorbutton2")
  84. self.colorbutton_math = self.builder.get_object("colorbutton_math")
  85. self.sb_ligne = self.builder.get_object("sb_ligne")
  86.  
  87.  
  88. self.comboTrigSource = self.builder.get_object("comboTrigSource")
  89. self.comboTrigFront = self.builder.get_object("comboTrigFront")
  90. self.scaleTrigger = self.builder.get_object("scaleTrigger")
  91. self.combo_math = self.builder.get_object("combo_math")
  92.  
  93. #Onglet Mesures :
  94. self.switch_aff_curseurY = self.builder.get_object("switch_aff_curseurY")
  95. self.colorbutton_curseurY = self.builder.get_object("colorbutton_curseurY")
  96. self.comboCurseurY = self.builder.get_object("comboCurseurY")
  97. self.scaleCAY = self.builder.get_object("scaleCAY")
  98. self.lb_CAY = self.builder.get_object("lb_CAY")
  99. self.scaleCBY = self.builder.get_object("scaleCBY")
  100. self.lb_CBY = self.builder.get_object("lb_CBY")
  101. self.lb_CdY = self.builder.get_object("lb_CdY")
  102.  
  103. self.switch_aff_curseurX= self.builder.get_object("switch_aff_curseurX")
  104. self.colorbutton_curseurX = self.builder.get_object("colorbutton_curseurX")
  105. self.scaleCAX = self.builder.get_object("scaleCAX")
  106. self.lb_CAX = self.builder.get_object("lb_CAX")
  107. self.scaleCBX = self.builder.get_object("scaleCBX")
  108. self.lb_CBX = self.builder.get_object("lb_CBX")
  109. self.lb_CdX = self.builder.get_object("lb_CdX")
  110.  
  111. self.label20 = self.builder.get_object("label20")
  112. self.lb_debug = self.builder.get_object("lb_debug")
  113. self.builder.connect_signals(self)
  114.  
  115. window = self.builder.get_object('window')
  116. window.show_all()
  117.  
  118. self.lister_ports()
  119. self.desactiver_widget_reglages()
  120.  
  121. #initialisations :
  122. self.ouvert = False
  123. self.timer_id = None
  124. self.sortie =""
  125. self.port_serie = " "
  126. self.port_choisi = " "
  127. self.data_format = " "
  128. self.debit = " "
  129. self.parite = ""
  130. self.comboPort.set_active(0) # le premier port decouvert
  131. self.comboBauds.set_active(2) # 38400 bauds
  132.  
  133. self.lb_idn.set_text("déconnecté")
  134. self.data_ch1 = [0]
  135.  
  136. self.Affiche_S1 = True
  137. self.Gnd1 = False
  138. self.Affiche_S2 = True
  139. self.Gnd2 = False
  140. self.Affiche_BdT = True
  141.  
  142. self.Affiche_ValCY = True
  143. self.Affiche_ValCX = True
  144.  
  145. self.data_ch2 = [0]
  146.  
  147. self.delai = 1000
  148.  
  149. self.longueur_data = 1024
  150. # tableau des difféentes valeurs de sensibilité à envoyer :
  151. self.env_cal = \
  152. ['0.000000001', '0.000000002', '0.000000005'\
  153. ,'0.00000001', '0.00000002', '0.00000005'\
  154. ,'0.0000001', '0.0000002', '0.0000005',\
  155. '0.000001', '0.000002', '0.000005',\
  156. '0.00001', '0.00002', '0.00005',\
  157. '0.0001', '0.0002', '0.0005',\
  158. '0.001','0.002', '0.005', \
  159. '0.01', '0.02', '0.05',\
  160. '0.1', '0.2', '0.5',\
  161. '1', '2', '5',\
  162. '10','20', '50']
  163.  
  164. # tableau des difféentes valeurs de sensibilité recevables :
  165. self.rec_cal = \
  166. ['1.000e-09','2.000e-09','5.000e-09', \
  167. '1.000e-08','2.000e-08','5.000e-08',\
  168. '1.000e-07','2.000e-07','5.000e-07',\
  169. '1.000e-06','2.000e-06','5.000e-06',\
  170. '1.000e-05','2.000e-05','5.000e-05',\
  171. '1.000e-04','2.000e-04','5.000e-04',\
  172. '1.000e-03','2.000e-03','5.000e-03',\
  173. '1.000e-02','2.000e-02','5.000e-02',\
  174. '1.000e-01','2.000e-01','5.000e-01',\
  175. '1.000e+00','2.000e+00','5.000e+00',\
  176. '1.000e+01','2.000e+01','5.000e+01']
  177.  
  178. #DS1062CD : 2 mV à 5V ; 5 ns à 50 s :
  179. self.index_Vmin = 19
  180. self.index_Vmax = 29
  181. self.index_Hmin = 2
  182. self.index_Hmax = 26 #version du logiciel limitée actuellement
  183.  
  184. #couleurs :
  185. self.couleur_fond = self.colorbutton_fond.get_rgba()
  186. self.couleur_ch1 = self.colorbutton1.get_rgba()
  187. self.couleur_ch2 = self.colorbutton2.get_rgba()
  188. self.couleur_math = self.colorbutton_math.get_rgba()
  189.  
  190. self.couleur_curseurX = self.colorbutton_curseurX.get_rgba()
  191. self.couleur_curseurY = self.colorbutton_curseurY.get_rgba()
  192.  
  193. adjLigne = Gtk.Adjustment(0, 1, 5, 1, 1, 0)
  194. self.sb_ligne.configure(adjLigne, 1,1)
  195. self.sb_ligne.set_value(3)
  196. self.epaisseur_ligne = int(self.sb_ligne.get_value())
  197.  
  198. self.Ch1active = True
  199. self.Ch2active = False
  200. self.ModeYT = True
  201. self.ModeXY = False
  202. self.Mathactive = False
  203. self.FFTactive = False
  204.  
  205. self.CurseurYactive = False
  206. self.PosCursYA = 110
  207. self.PosCursYB = 210
  208. self.PosCursXA = 210
  209. self.PosCursXB = 410
  210. self.CurseurXactive = False
  211. self.comboCurseurY.set_active(0)
  212.  
  213. # masque de recherche des valeurs numériques :
  214. # exemple 2.000e+01
  215. self.masque = re.compile('([0-9])\.([0-9]+)e\D([0-9])([0-9])')
  216. #masque de recherche trigger :
  217. self.masque_trigger = re.compile('([A-Z0-9]+)')
  218. self.masque_triggerFront = re.compile('([A-Z]+)')
  219. self.masque_trigger_niveau = re.compile('(\-*[0-9])\.([0-9]+)e\D([0-9])([0-9])')
  220. #masque de recherche couplages :
  221. self.masque_couplage = re.compile('([A-Z]+)')
  222.  
  223. def lister_ports(self) :
  224. if sys.platform.startswith('linux'): #test du système d'exploitation
  225. # sous Linux
  226. list_port = glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyS*')
  227.  
  228. # puis affichage des ports dans le combo :
  229. i = 0
  230. while i < len(list_port):
  231. self.comboPort.append_text(list_port[i].strip('/dev/'))
  232. i=i+1
  233.  
  234. def desactiver_widget_reglages(self):
  235. self.btFermer.set_sensitive(False)
  236. self.bt_Manuel.set_sensitive(False)
  237. self.bt_Auto.set_sensitive(False)
  238. self.tgb_RunStop.set_sensitive(False)
  239. self.scaleCH1.set_sensitive(False)
  240. self.bt_plus_ch1.set_sensitive(False)
  241. self.sw_ch1.set_sensitive(False)
  242. self.bt_moins_ch1.set_sensitive(False)
  243. self.scaleCH2.set_sensitive(False)
  244. self.sw_ch2.set_sensitive(False)
  245. self.bt_plus_ch2.set_sensitive(False)
  246. self.bt_moins_ch2.set_sensitive(False)
  247. self.sw_math.set_sensitive(False)
  248. self.combo_math.set_sensitive(False)
  249. #self.comboBdT.set_sensitive(False)
  250. self.bt_plus_BdT.set_sensitive(False)
  251. self.bt_moins_BdT.set_sensitive(False)
  252. self.scaleBdT.set_sensitive(False)
  253. self.scaleCH1.set_sensitive(False)
  254. self.bt_plus_ch1.set_sensitive(False)
  255. self.comboTrigSource.set_sensitive(False)
  256. self.comboTrigFront.set_sensitive(False)
  257. self.scaleTrigger.set_sensitive(False)
  258.  
  259. def activer_widget_reglages(self):
  260. self.btFermer.set_sensitive(True)
  261. self.bt_Manuel.set_sensitive(True)
  262. self.bt_Auto.set_sensitive(True)
  263. self.tgb_RunStop.set_sensitive(True)
  264. self.scaleCH1.set_sensitive(True)
  265. self.bt_plus_ch1.set_sensitive(True)
  266. self.sw_ch1.set_sensitive(True)
  267. self.bt_moins_ch1.set_sensitive(True)
  268. self.scaleCH2.set_sensitive(True)
  269. self.sw_ch2.set_sensitive(True)
  270. self.bt_plus_ch2.set_sensitive(True)
  271. self.bt_moins_ch2.set_sensitive(True)
  272. #self.sw_math.set_sensitive(True)
  273. #self.combo_math.set_sensitive(True)
  274. self.comboBdT.set_sensitive(True)
  275. self.scaleBdT.set_sensitive(True)
  276. self.bt_plus_BdT.set_sensitive(True)
  277. self.bt_moins_BdT.set_sensitive(True)
  278. self.scaleCH1.set_sensitive(True)
  279. self.bt_plus_ch1.set_sensitive(True)
  280. self.comboTrigSource.set_sensitive(True)
  281. self.comboTrigFront.set_sensitive(True)
  282. self.scaleTrigger.set_sensitive(True)
  283.  
  284. def lire_reglages_sensibilites(self):
  285. try:
  286. #récupérer la sensibilité CH1 :
  287. self.port_serie.write(':CHAN1:SCAL?' + '\n')
  288. sleep(0.01)
  289. self.sensib1 = self.masque.search(self.port_serie.readline()).group(0)
  290.  
  291. if self.Affiche_S1 == True :
  292. if float(self.sensib1) < 1 :
  293. self.lb_CH1.set_text(str(int(1000*float(self.sensib1))) + " mV/div")
  294. else:
  295. self.lb_CH1.set_text(str(int(float(self.sensib1))) + " V/div")
  296. else:
  297. self.lb_CH1.set_text("")
  298. #recuperation de l'indice (dans le tableau) du calibre de la voie 1
  299. self.index1 = self.rec_cal.index(self.sensib1)
  300.  
  301. #récupérer la sensibilité CH2 :
  302. self.port_serie.write(':CHAN2:SCAL?' + '\n')
  303. sleep(0.01)
  304. self.sensib2 = self.masque.search(self.port_serie.readline()).group(0)
  305. if self.Affiche_S2 == True :
  306. if float(self.sensib2) < 1 :
  307. self.lb_CH2.set_text(str(int(1000*float(self.sensib2))) + " mV/div")
  308. else:
  309. self.lb_CH2.set_text(str(int(float(self.sensib2))) + " V/div")
  310. else:
  311. self.lb_CH2.set_text("")
  312. self.index2 = self.rec_cal.index(self.sensib2)
  313.  
  314. #récupérer la sensibilité horizontale :
  315. self.port_serie.write(':TIM:SCAL?' + '\n')
  316. sleep(0.01)
  317. self.BdT = self.masque.search(self.port_serie.readline()).group(0)
  318. if self.Affiche_BdT == True :
  319. if float(self.BdT) < 1E-6 :
  320. self.lb_BdT.set_text(str(int(1E9*float(self.BdT))) + " ns/div")
  321. elif float(self.BdT) < 1E-3 :
  322. self.lb_BdT.set_text(str(int(1E6*float(self.BdT))) + " " + u"\u03BC" + "s/div")
  323. elif float(self.BdT) < 1 :
  324. self.lb_BdT.set_text(str(int(1E3*float(self.BdT))) + " ms/div")
  325. else:
  326. self.lb_BdT.set_text(str(int(float(self.BdT))) + " s/div")
  327. else:
  328. self.lb_BdT.set_text("")
  329. self.indexH = self.rec_cal.index(self.BdT)
  330. self.lb_debug.set_text('')
  331. except :
  332. self.lb_debug.set_text('erreur de lecture')
  333.  
  334. def lire_couplages(self):
  335. #récupérer le mode de couplage sur chacune des voies :
  336. try:
  337. self.port_serie.write(':CHANnel1:COUPling?' + '\n')
  338. sleep(0.01)
  339. self.Couplage1_Oscillo = self.masque_couplage.search(self.port_serie.readline()).group(0)
  340.  
  341. if self.Couplage1_Oscillo == 'DC' :
  342. self.combo_couplage1.set_active(0)
  343. elif self.Couplage1_Oscillo == 'AC' :
  344. self.combo_couplage1.set_active(1)
  345. elif self.Couplage1_Oscillo == 'GND' :
  346. self.combo_couplage1.set_active(2)
  347. self.Gnd1 = True
  348. else :
  349. self.combo_couplage1.set_active(0)
  350. self.port_serie.write(':CHANnel1:COUPling DC' + '\n' )
  351.  
  352. self.port_serie.write(':CHANnel2:COUPling?' + '\n')
  353. sleep(0.01)
  354. self.Couplage2_Oscillo = self.masque_couplage.search(self.port_serie.readline()).group(0)
  355.  
  356. if self.Couplage2_Oscillo == 'DC' :
  357. self.combo_couplage2.set_active(0)
  358. elif self.Couplage2_Oscillo == 'AC' :
  359. self.combo_couplage2.set_active(1)
  360. elif self.Couplage2_Oscillo == 'GND' :
  361. self.combo_couplage2.set_active(2)
  362. self.Gnd2 = True
  363. else :
  364. self.combo_couplage2.set_active(0)
  365. self.port_serie.write(':CHANnel2:COUPling DC' + '\n' )
  366. except :
  367. self.lb_debug.set_text('erreur de lecture')
  368.  
  369. def lire_reglages_trigger(self):
  370. #récupérer les réglages trigger :
  371. try:
  372. # source du trigger :
  373. self.port_serie.write(':TRIG:EDGE:SOUR?' + '\n')
  374. sleep(0.01)
  375. self.TrigSourceOscillo = self.masque_trigger.search(self.port_serie.readline()).group(0)
  376.  
  377. if self.TrigSourceOscillo == 'CH1' :
  378. self.comboTrigSource.set_active(0)
  379. elif self.TrigSourceOscillo == 'CH2' :
  380. self.comboTrigSource.set_active(1)
  381. elif self.TrigSourceOscillo == 'EXT' :
  382. self.comboTrigSource.set_active(2)
  383. else :
  384. self.comboTrigSource.set_active(0)
  385. self.port_serie.write(':TRIG:EDGE:SOUR CH1' + '\n' )
  386.  
  387. # Front du trigger :
  388. self.port_serie.write(':TRIGger:EDGE:SLOPe?' + '\n')
  389. sleep(0.01)
  390.  
  391. self.TrigFrontOscillo = self.masque_triggerFront.search(self.port_serie.readline()).group(0)
  392.  
  393. if self.TrigFrontOscillo == 'POSITIVE' :
  394. self.comboTrigFront.set_active(0)
  395. elif self.TrigFrontOscillo == 'NEGATIVE' :
  396. self.comboTrigFront.set_active(1)
  397.  
  398. else :
  399. self.comboTrigFront.set_active(0)
  400. self.port_serie.write(':TRIG:EDGE:SLOP POS' + '\n' )
  401.  
  402. # niveau du trigger :
  403. self.port_serie.write(':TRIG:EDGE:LEV?' + '\n')
  404. sleep(0.01)
  405. self.niveau_trigger_oscillo = float(self.masque_trigger_niveau.search(self.port_serie.readline()).group(0) )
  406. self.scaleTrigger.set_value(10*self.niveau_trigger_oscillo)
  407. self.lb_niveau_trigger.set_text(str("{:1.2f}".format(float(self.sensib1)*self.niveau_trigger_oscillo/10) + 'V'))
  408.  
  409. except :
  410. self.lb_debug.set_text('erreur de lecture')
  411.  
  412.  
  413. def on_colorbutton_fond_color_set(self, user_data):
  414. self.couleur_fond = self.colorbutton_fond.get_rgba()
  415. self.zone_ecran.queue_draw()
  416.  
  417.  
  418. def on_colorbutton_math_color_set(self, user_data):
  419. self.couleur_math = self.colorbutton_math.get_rgba()
  420. self.zone_ecran.queue_draw()
  421.  
  422. def on_colorbutton1_color_set(self, user_data):
  423. self.couleur_ch1 = self.colorbutton1.get_rgba()
  424. self.zone_ecran.queue_draw()
  425.  
  426. def on_colorbutton2_color_set(self, user_data):
  427. self.couleur_ch2 = self.colorbutton2.get_rgba()
  428. self.zone_ecran.queue_draw()
  429.  
  430. def on_sb_ligne_value_changed(self, user_data):
  431. self.epaisseur_ligne = int(self.sb_ligne.get_value())
  432. self.zone_ecran.queue_draw()
  433.  
  434. def on_bt_aff_ch1_toggled(self,widget):
  435. if widget.get_active():
  436. self.Affiche_S1 = False
  437. self.lb_CH1.set_text("")
  438. else:
  439. self.Affiche_S1 = True
  440.  
  441. def on_bt_aff_ch2_toggled(self,widget):
  442. if widget.get_active():
  443. self.Affiche_S2 = False
  444. self.lb_CH2.set_text("")
  445. else:
  446. self.Affiche_S2 = True
  447.  
  448. def on_bt_aff_bdt_toggled(self,widget):
  449. if widget.get_active():
  450. self.Affiche_BdT = False
  451. self.lb_BdT.set_text("")
  452. else:
  453. self.Affiche_BdT = True
  454.  
  455. def tracer_grille(self,cr):
  456. self.epaisseur_ligne = int(self.sb_ligne.get_value())
  457. #Tracé du tour et des axes centraux :
  458. cr.set_line_width(2)
  459. cr.set_source_rgb(self.couleur_fond.red,self.couleur_fond.green,self.couleur_fond.blue)
  460. cr.rectangle(0, 0, 620, 580)
  461. cr.fill()
  462. cr.set_source_rgb(0,0,0)
  463. cr.move_to(10,10)
  464. cr.rel_line_to(0, 400)
  465. cr.rel_line_to(600,0)
  466. cr.rel_line_to(0,-400)
  467. cr.rel_line_to(-600,0)
  468. cr.move_to(10,210)
  469. cr.rel_line_to(600,0)
  470. cr.move_to(310,10)
  471. cr.rel_line_to(0,400)
  472. for i in range (40):
  473. cr.move_to(305,10*i + 10)
  474. cr.rel_line_to(10,0)
  475. for i in range (120):
  476. cr.move_to(10 * i + 10,205)
  477. cr.rel_line_to(0,10)
  478. cr.stroke()
  479. # tracé de la grille secondaire :
  480. cr.set_line_width(0.5)
  481. for i in range (12):
  482. cr.move_to(50 * i + 10,10)
  483. cr.rel_line_to(0,400)
  484. for i in range (8):
  485. cr.move_to(10,50*i + 10)
  486. cr.rel_line_to(600,0)
  487. cr.stroke()
  488.  
  489. def tracer_courbes(self,cr):
  490. cr.set_line_width(self.epaisseur_ligne)
  491.  
  492. if self.ModeYT == True:
  493. if self.Ch1active == True:
  494. #tracé de CH1:
  495.  
  496. cr.set_source_rgb(self.couleur_ch1.red,self.couleur_ch1.green,self.couleur_ch1.blue)
  497. try:
  498. #tracé du repère 0 de la voie 1
  499. cr.move_to(0 ,210 - 5*self.scaleCH1.get_value())
  500. cr.line_to(10, 210 - 5*self.scaleCH1.get_value())
  501. cr.stroke()
  502. #tracé du repère du trigger :
  503. if self.TrigSource == 0:
  504. cr.move_to(310 - 5*self.scaleBdT.get_value(), 0)
  505. cr.line_to(310 - 5*self.scaleBdT.get_value(), 10)
  506. cr.stroke()
  507. #tracé de la courbe CH1
  508. for i in range (217,816):
  509. if self.Gnd1 == False:
  510. cr.move_to(i-207 ,2*self.data_ch1[i]-40)
  511. cr.line_to(i-206, 2*(self.data_ch1[i+1])-40)
  512. cr.stroke()
  513. else:
  514. cr.move_to(0 ,210 - 5*self.scaleCH1.get_value())
  515. cr.line_to(610, 210 - 5*self.scaleCH1.get_value())
  516. cr.stroke()
  517.  
  518. except:
  519. self.lb_debug.set_text("")
  520.  
  521.  
  522. if self.Ch2active == True:
  523. #tracé de CH2:
  524.  
  525. cr.set_source_rgb(self.couleur_ch2.red,self.couleur_ch2.green,self.couleur_ch2.blue)
  526.  
  527. try:
  528. cr.move_to(0 ,210 - 5*self.scaleCH2.get_value())
  529. cr.line_to(10, 210 - 5*self.scaleCH2.get_value())
  530. cr.stroke()
  531. #tracé du repère du trigger :
  532. if self.TrigSource == 1:
  533. cr.move_to(310 - 5*self.scaleBdT.get_value(), 0)
  534. cr.line_to(310 - 5*self.scaleBdT.get_value(), 10)
  535. cr.stroke()
  536. for i in range (217,816):
  537. if self.Gnd2 == False:
  538. cr.move_to(i-207 ,2*self.data_ch2[i]-40)
  539. cr.line_to(i-206, 2*(self.data_ch2[i+1])-40)
  540. cr.stroke()
  541. else:
  542. cr.move_to(0 ,210 - 5*self.scaleCH2.get_value())
  543. cr.line_to(610, 210 - 5*self.scaleCH2.get_value())
  544. cr.stroke()
  545.  
  546. except:
  547. self.lb_debug.set_text("")
  548. if self.FFTactive == True:
  549. #tracé de la FFT:
  550. cr.set_line_width(self.epaisseur_ligne)
  551. cr.set_source_rgb(self.couleur_math.red,self.couleur_math.green,self.couleur_math.blue)
  552. try:
  553. for i in range (217,816):
  554. cr.move_to(i-207 ,2*self.data_FFT[i]-40)
  555. cr.line_to(i-206, 2*(self.data_FFT[i+1])-40)
  556. cr.stroke()
  557.  
  558. except:
  559. self.lb_debug.set_text("")
  560.  
  561. #Mode XY
  562. if self.ModeXY == True:
  563.  
  564. #tracé de la courbe XY
  565. cr.set_line_width(self.epaisseur_ligne)
  566. cr.set_source_rgb(self.couleur_ch1.red,self.couleur_ch1.green,self.couleur_ch1.blue)
  567. if self.Ch1active == True and self.Ch2active == True:
  568. for i in range (217,816):
  569. if (self.Gnd1 == False) and (self.Gnd2 == False):
  570. cr.move_to(560-2*self.data_ch1[i] , 2*self.data_ch2[i] -40 )
  571. cr.line_to(560-2*self.data_ch1[i+1], 2* self.data_ch2[i+1] -40)
  572. else:
  573. self.lb_debug.set_text('Choisir un couplage <> GND')
  574. cr.stroke()
  575.  
  576. def on_zone_ecran_draw(self, widget,cr):
  577. self.tracer_grille(cr)
  578. self.tracer_courbes(cr)
  579. self.tracer_curseurs(cr)
  580.  
  581. def on_zone_ecran_button_press_event(self, widget, event):
  582. print "Mouse clicked... at ", event.x, ", ", event.y
  583. # How to draw a line starting at this point on the drawing area?
  584. return True
  585.  
  586. def on_sw_ch1_button_press_event(self,widget,event):
  587. self.Ch1active = not self.Ch1active
  588.  
  589. def on_bt_plus_ch1_clicked(self,widget):
  590. if (self.index1 < self.index_Vmax) :
  591. self.port_serie.write(':CHAN1:SCAL ' + self.env_cal[self.index1 +1] + '\n' )
  592. sleep(0.01)
  593. self.lire_reglages_sensibilites()
  594.  
  595. def on_bt_moins_ch1_clicked(self,widget):
  596. if (self.index1 > self.index_Vmin) :
  597. self.port_serie.write(':CHAN1:SCAL ' + self.env_cal[self.index1 - 1] + '\n' )
  598. sleep(0.01)
  599. self.lire_reglages_sensibilites()
  600.  
  601. def on_scaleCH1_value_changed(self,widget):
  602. self.decalage_CH1 = self.scaleCH1.get_value()
  603. self.envoi_decalage_CH1 = str(float(self.sensib1)*self.decalage_CH1/10)
  604.  
  605. self.port_serie.write(':CHAN1:OFFS ' + (self.envoi_decalage_CH1) + '\n')
  606. sleep(0.01)
  607.  
  608. def on_scaleCH1_button_press_event(self,widget,event):
  609. self.scaleCH1.set_value(0)
  610.  
  611. def on_combo_couplage1_changed(self,widget):
  612. #régler couplage CH1 selon choix logiciel :
  613. self.Couplage1 = self.combo_couplage1.get_active()
  614. if self.Couplage1 == 0:
  615. self.Gnd1 = False
  616. self.port_serie.write(':CHANnel1:COUPling DC' + '\n' )
  617. if self.Couplage1 == 1:
  618. self.Gnd1 = False
  619. self.port_serie.write(':CHANnel1:COUPling AC' + '\n' )
  620. if self.Couplage1 == 2:
  621. self.port_serie.write(':CHANnel1:COUPling GND' + '\n' )
  622. self.Gnd1 = True
  623.  
  624. def on_bt_plus_ch2_clicked(self,widget):
  625. if (self.index2 < self.index_Vmax) :
  626. self.port_serie.write(':CHAN2:SCAL ' + self.env_cal[self.index2 +1] + '\n' )
  627. sleep(0.01)
  628. self.lire_reglages_sensibilites()
  629.  
  630. def on_bt_moins_ch2_clicked(self,widget):
  631. if (self.index2 > self.index_Vmin) :
  632. self.port_serie.write(':CHAN2:SCAL ' + self.env_cal[self.index2 - 1] + '\n' )
  633. sleep(0.01)
  634. self.lire_reglages_sensibilites()
  635.  
  636. def on_scaleCH2_value_changed(self,widget):
  637. self.decalage_CH2 = self.scaleCH2.get_value()
  638. self.envoi_decalage_CH2 = str(float(self.sensib2)*self.decalage_CH2/10)
  639.  
  640. self.port_serie.write(':CHAN2:OFFS ' + (self.envoi_decalage_CH2) + '\n')
  641. sleep(0.01)
  642.  
  643. def on_scaleCH2_button_press_event(self,widget,event):
  644. self.scaleCH2.set_value(0)
  645.  
  646. def on_combo_couplage2_changed(self,widget):
  647. #régler couplage CH2 selon choix logiciel :
  648. self.Couplage2 = self.combo_couplage2.get_active()
  649. if self.Couplage2 == 0:
  650. self.Gnd2 = False
  651. self.port_serie.write(':CHANnel2:COUPling DC' + '\n' )
  652. if self.Couplage2 == 1:
  653. self.Gnd2 = False
  654. self.port_serie.write(':CHANnel2:COUPling AC' + '\n' )
  655. if self.Couplage2 == 2:
  656. self.Gnd2=True
  657. self.port_serie.write(':CHANnel2:COUPling GND' + '\n' )
  658.  
  659. def on_bt_plus_BdT_clicked(self,widget):
  660.  
  661. if (self.indexH < self.index_Hmax) :
  662. self.port_serie.write(':TIM:SCAL ' + self.env_cal[self.indexH +1] + '\n' )
  663. sleep(0.01)
  664. self.lire_reglages_sensibilites()
  665.  
  666. def on_bt_moins_BdT_clicked(self,widget):
  667. if (self.indexH > self.index_Hmin) :
  668. self.port_serie.write(':TIM:SCAL ' + self.env_cal[self.indexH - 1] + '\n' )
  669. sleep(0.01)
  670. self.lire_reglages_sensibilites()
  671.  
  672. def on_scaleBdT_value_changed(self,widget):
  673. self.decalage_Horizontal = self.scaleBdT.get_value()
  674. self.envoi_decalage_Horizontal = str("{:1.8f}".format(float(self.BdT)*self.decalage_Horizontal/10))
  675. self.port_serie.write(':TIM:OFFS ' + (self.envoi_decalage_Horizontal) + '\n')
  676. sleep(0.01)
  677. self.lb_decalage_horizontal.set_text(str("{:1.1f}".format(float(-self.decalage_Horizontal/10)) + ' div'))
  678.  
  679. def on_scaleBdT_button_press_event(self,widget,event):
  680. self.scaleBdT.set_value(0)
  681.  
  682. def on_comboBdT_changed(self,widget):
  683. self.lb_CAX.set_text(' ')
  684. self.lb_CAY.set_text(' ')
  685. self.lb_CBX.set_text(' ')
  686. self.lb_CBY.set_text(' ')
  687. self.lb_CdX.set_text(' ')
  688. self.lb_CdY.set_text(' ')
  689.  
  690. #choisir le mode : YT ou XY
  691. self.FormatBdt = self.comboBdT.get_active()
  692. if self.FormatBdt == 0:
  693. self.comboCurseurY.set_sensitive(True)
  694. self.port_serie.write(':TIM:FORM YT' + '\n' )
  695. self.ModeYT = True
  696. self.ModeXY = False
  697.  
  698. if self.FormatBdt == 1:
  699. self.comboCurseurY.set_active(1)
  700. self.comboCurseurY.set_sensitive(False)
  701. if self.Ch1active == False :
  702. self.sw_ch1.set_active(True)
  703. self.Ch1active = True
  704. if self.Ch2active == False :
  705. self.sw_ch2.set_active(True)
  706. self.Ch2active = True
  707. #self.port_serie.write(':TIM:FORM XY' + '\n' )
  708. self.ModeYT = False
  709. self.ModeXY = True
  710.  
  711. def on_sw_ch2_button_press_event(self,widget,event):
  712. self.Ch2active = not self.Ch2active
  713.  
  714.  
  715. def on_comboTrigSource_changed(self,widget):
  716. #régler Trigger selon choix logiciel :
  717. self.TrigSource = self.comboTrigSource.get_active()
  718. if self.TrigSource == 0:
  719. self.port_serie.write(':TRIG:EDGE:SOURce CHANnel1' + '\n' )
  720. if self.TrigSource == 1:
  721. self.port_serie.write(':TRIG:EDGE:SOURce CHANnel2' + '\n' )
  722. if self.TrigSource == 2:
  723. self.port_serie.write(':TRIG:EDGE:SOURce EXT' + '\n' )
  724.  
  725.  
  726.  
  727. def on_comboTrigFront_changed(self,widget):
  728. self.TrigFront = self.comboTrigFront.get_active()
  729. if self.TrigFront == 0 :
  730. self.port_serie.write(':TRIGger:EDGE:SLOPe POSitive' + '\n' )
  731. if self.TrigFront == 1 :
  732. self.port_serie.write(':TRIGger:EDGE:SLOPe NEGative' + '\n' )
  733.  
  734. def on_scaleTrigger_value_changed(self,widget):
  735. self.niveau_trigger = self.scaleTrigger.get_value()
  736. if self.TrigSource == 0:
  737. self.envoi_trigger = str(float(self.sensib1)*self.niveau_trigger/10)
  738. self.lb_niveau_trigger.set_text(str("{:1.2f}".format(float(self.sensib1)*self.niveau_trigger/10) + 'V'))
  739. if self.TrigSource == 1:
  740. self.envoi_trigger = str(float(self.sensib2)*self.niveau_trigger/10)
  741. self.lb_niveau_trigger.set_text(str("{:1.2f}".format(float(self.sensib2)*self.niveau_trigger/10) + 'V'))
  742.  
  743. self.port_serie.write(':TRIG:EDGE:LEV ' + (self.envoi_trigger) + '\n')
  744. sleep(0.01)
  745.  
  746. def on_scaleTrigger_button_press_event(self,widget,event):
  747. self.scaleTrigger.set_value(0)
  748.  
  749. def acquisition(self):
  750. if self.timer_id is not None:
  751. self.port_serie.flushInput()
  752.  
  753. self.lire_reglages_sensibilites()
  754.  
  755. self.port_serie.write(':WAV:POIN:MODE NOR' + '\n' )
  756. sleep(0.01)
  757. #acquisition voie 1 :
  758. self.port_serie.flushInput()
  759. sleep(0.01)
  760. for i in range (self.longueur_data):
  761. self.data_ch1 = [0]
  762. self.data_ch2 = [0]
  763. self.data_FFT = [0]
  764.  
  765. if self.Ch1active == True:
  766. self.port_serie.write(':WAVeform:DATA? CHANnel1' + '\n')
  767. sleep(0.3)
  768.  
  769. lecture1 = self.port_serie.read(self.longueur_data)
  770. try:
  771. for i in range (self.longueur_data):
  772. self.data_ch1.append(ord(lecture1[i]))
  773. except:
  774. self.lb_debug.set_text("")
  775.  
  776. #acquisition voie 2 :
  777. self.port_serie.flushInput()
  778. sleep(0.01)
  779.  
  780. if self.Ch2active == True:
  781. self.port_serie.write(':WAVeform:DATA? CHANnel2' + '\n')
  782. sleep(0.1)
  783.  
  784. lecture2 = self.port_serie.read(self.longueur_data)
  785. try:
  786. for i in range (self.longueur_data):
  787. self.data_ch2.append(ord(lecture2[i]))
  788. except:
  789. self.lb_debug.set_text("")
  790.  
  791. if self.FFTactive == True:
  792. self.port_serie.write(':WAVeform:DATA? FFT' + '\n')
  793. sleep(0.3)
  794.  
  795. lectureFFT = self.port_serie.read(self.longueur_data)
  796. try:
  797. for i in range (self.longueur_data):
  798. self.data_FFT.append(ord(lectureFFT[i]))
  799. except:
  800. self.lb_debug.set_text("")
  801.  
  802. self.zone_ecran.queue_draw()
  803. return True
  804.  
  805. return False
  806.  
  807.  
  808.  
  809. def on_btRafraichir_clicked(self,widget):
  810. #Rafraichir la liste des ports série disponibles
  811. self.comboPort.remove_all()
  812. self.lister_ports()
  813.  
  814. def on_btOuvrir_clicked(self,widget):
  815. # recuperation des parametres choisis :
  816. self.port_choisi = '/dev/' + self.comboPort.get_active_text()
  817. debit = self.comboBauds.get_active_text()
  818.  
  819. data_format = serial.EIGHTBITS
  820. stop = serial.STOPBITS_ONE
  821. parite = serial.PARITY_NONE
  822. try:
  823. # desactivation de widgets (ceux qui ne doivent pas
  824. # etre modifies une fois le port serie ouvert) :
  825. self.comboPort.set_sensitive(False)
  826. self.btRafraichir.set_sensitive(False)
  827. self.btQuitter.set_sensitive(True)
  828.  
  829.  
  830. #ouverture du port serie :
  831. self.port_serie = serial.Serial(
  832. port=self.port_choisi,
  833. baudrate = debit,
  834. bytesize = data_format,
  835. parity = parite,
  836. stopbits = stop,
  837. timeout=2
  838. )
  839.  
  840. #activation/desactivation de widgets :
  841. self.btFermer.set_sensitive(True)
  842. self.btOuvrir.set_sensitive(False)
  843. self.comboBauds.set_sensitive(False)
  844. self.activer_widget_reglages()
  845. #vidage du port et tentative de contact :
  846. self.port_serie.flushInput()
  847.  
  848. self.port_serie.write('*IDN?' + '\n')
  849. #petit délai avant de lire le retour :
  850. sleep(0.1)
  851. data = []
  852.  
  853. n_data = 0
  854. n_data = self.port_serie.inWaiting()
  855. sleep(0.1)
  856. if n_data > 0 :
  857. chaine = ""
  858. for i in range (n_data) :
  859. data.append(ord(self.port_serie.read(1)))
  860.  
  861. chaine += chr(data[i])
  862. identite = chaine.split(',')
  863. self.lb_idn.set_text(identite[1])
  864.  
  865. self.port_serie.write(':KEY:LOCK ENABLE' + '\n')
  866. sleep(0.01)
  867. self.port_serie.write(':STOP' + '\n')
  868. sleep(0.01)
  869.  
  870. self.port_serie.write(':TRIGger:EDGE:SWEep NORMAL' + '\n')
  871. sleep(0.01)
  872. # ces deux lignes à déplacer par la suite :
  873. self.port_serie.write(':TIM:MODE MAIN' + '\n')
  874. sleep(0.01)
  875.  
  876. self.lire_reglages_sensibilites()
  877. self.lire_reglages_trigger()
  878. self.lire_couplages()
  879. self.comboBdT.set_active(0)
  880. self.ouvert = True
  881.  
  882. except :
  883. self.comboPort.set_sensitive(True)
  884. self.btOuvrir.set_sensitive(True)
  885. self.btRafraichir.set_sensitive(True)
  886. self.ouvert = False
  887. #self.bt_fermer.set_sensitive(False)
  888. self.ouvert = False
  889. msg = "Erreur lors de l'ouverture du port série : ce port n'est peut-être pas valide, ou bien vous n'avez pas les droits pour accéder aux ports série"
  890. dialog = Gtk.MessageDialog(None, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, msg)
  891. # Montre le dialog
  892. dialog.run()
  893. # Destruction du dialog
  894. dialog.destroy()
  895.  
  896. def fermer_port(self):
  897. try :
  898. if self.ouvert == True:
  899. self.port_serie.write(':STOP' + '\n')
  900. self.port_serie.write(':KEY:LOCK DISABLE' + '\n')
  901. self.port_serie.close()
  902. self.comboPort.set_sensitive(True)
  903. self.comboBauds.set_sensitive(True)
  904. self.btOuvrir.set_sensitive(True)
  905. self.btRafraichir.set_sensitive(True)
  906. self.btFermer.set_sensitive(False)
  907. self.lb_idn.set_text("Etat : déconnecté ")
  908. self.desactiver_widget_reglages()
  909. self.ouvert = False
  910. except :
  911. msgFermer = "Erreur lors de la fermeture du port série !"
  912. dlgFermer = Gtk.MessageDialog(None, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, msgFermer)
  913. dlgFermer.run()
  914. dlgFermer.destroy()
  915.  
  916. def on_btFermer_clicked(self,widget):
  917. #fermeture du port série ouvert
  918. self.fermer_port()
  919.  
  920. def on_bt_Auto_clicked(self,widget):
  921.  
  922. self.port_serie.write(':AUTO' + '\n')
  923. self.tgb_RunStop.set_active(True)
  924.  
  925. def on_tgb_RunStop_toggled(self,widget):
  926.  
  927. if widget.get_active():
  928. self.lire_reglages_sensibilites()
  929. self.lire_couplages()
  930. self.lire_reglages_trigger()
  931. # met les deux entrées en coef 1 :
  932. self.port_serie.write(':CHAN1:PROB 1' + '\n')
  933. sleep(0.01)
  934. self.port_serie.write(':CHAN2:PROB 1' + '\n')
  935. sleep(0.01)
  936. # mode YT :
  937. self.port_serie.write(':TIM:FORM YT' + '\n' )
  938. sleep(0.01)
  939. #mode Run :
  940. self.port_serie.write(':RUN' + '\n')
  941. sleep(0.01)
  942.  
  943. self.timer_id = GObject.timeout_add(self.delai, self.acquisition)
  944. self.btFermer.set_sensitive(False)
  945. self.btQuitter.set_sensitive(False)
  946. else:
  947. self.timer_id = None
  948. self.port_serie.write(':STOP' + '\n')
  949. self.btFermer.set_sensitive(True)
  950. self.btQuitter.set_sensitive(True)
  951.  
  952. def on_bt_Manuel_clicked(self,widget):
  953.  
  954. self.port_serie.write(':KEY:LOCK DISABLE' + '\n')
  955.  
  956. # Onglet Mesures :
  957. # curseurs horizontaux :
  958. def on_switch_aff_curseurY_button_press_event(self,widget,event):
  959. self.CurseurYactive = not self.CurseurYactive
  960.  
  961. def on_colorbutton_curseurY_color_set(self, user_data):
  962. self.couleur_curseurY = self.colorbutton_curseurY.get_rgba()
  963. self.zone_ecran.queue_draw()
  964.  
  965. def on_tgb_Affiche_ValCY_toggled(self,widget):
  966. if widget.get_active():
  967. self.Affiche_ValCY = False
  968. self.lb_CAY.set_text("")
  969. self.lb_CBY.set_text("")
  970. self.lb_CdY.set_text("")
  971. else:
  972. self.Affiche_ValCY = True
  973.  
  974. def on_scaleCAY_value_changed(self,widget):
  975. self.PosCursYA = self.scaleCAY.get_value()
  976.  
  977.  
  978. def on_scaleCBY_value_changed(self,widget):
  979. self.PosCursYB = self.scaleCBY.get_value()
  980.  
  981. # curseurs verticaux
  982. def on_switch_aff_curseurX_button_press_event(self,widget,event):
  983. self.CurseurXactive = not self.CurseurXactive
  984.  
  985. def on_colorbutton_curseurX_color_set(self, user_data):
  986. self.couleur_curseurX = self.colorbutton_curseurX.get_rgba()
  987. self.zone_ecran.queue_draw()
  988.  
  989. def on_tgb_Affiche_ValCX_toggled(self,widget):
  990. if widget.get_active():
  991. self.Affiche_ValCX = False
  992. self.lb_CAX.set_text("")
  993. self.lb_CBX.set_text("")
  994. self.lb_CdX.set_text("")
  995. else:
  996. self.Affiche_ValCX = True
  997.  
  998. def on_scaleCAX_value_changed(self,widget):
  999. self.PosCursXA = self.scaleCAX.get_value()
  1000.  
  1001. def on_scaleCBX_value_changed(self,widget):
  1002. self.PosCursXB = self.scaleCBX.get_value()
  1003.  
  1004. def tracer_curseurs(self,cr):
  1005. if self.CurseurYactive == True:
  1006. #tracé des curseurs horizontaux :
  1007. cr.set_dash([12,12])
  1008. cr.set_source_rgb(self.couleur_curseurY.red,self.couleur_curseurY.green,self.couleur_curseurY.blue)
  1009. cr.move_to(10 ,self.PosCursYA)
  1010. cr.line_to(610, self.PosCursYA)
  1011. cr.move_to(10 ,self.PosCursYB)
  1012. cr.line_to(610, self.PosCursYB)
  1013. cr.stroke()
  1014. #affichage des valeurs des curseurs horizontaux :
  1015. if self.Affiche_ValCY == True:
  1016. if self.ModeYT == True:
  1017. self.ChoixVoie = self.comboCurseurY.get_active()
  1018. if self.ChoixVoie == 0:
  1019. self.sensib = self.sensib1
  1020. if self.ChoixVoie == 1:
  1021. self.sensib = self.sensib2
  1022. if self.ModeXY == True:
  1023. self.sensib = self.sensib2
  1024.  
  1025. self.ValCA = float(self.sensib)*((210 - 5*self.scaleCH1.get_value())-self.PosCursYA)
  1026. self.ValCB = float(self.sensib)*((210 - 5*self.scaleCH1.get_value())-self.PosCursYB)
  1027. if float(self.sensib) < 1 :
  1028. self.lb_CAY.set_text(str(int(20*self.ValCA)) + " mV")
  1029. self.lb_CBY.set_text(str(int(20*self.ValCB)) + " mV")
  1030. self.lb_CdY.set_text(str(int(20*(self.ValCA - self.ValCB))) + " mV")
  1031. else:
  1032. self.lb_CAY.set_text(str("{:1.2f}".format(0.02*self.ValCA) + " V"))
  1033. self.lb_CBY.set_text(str("{:1.2f}".format(0.02*self.ValCB) + " V"))
  1034. self.lb_CdY.set_text(str("{:1.2f}".format(0.02*(self.ValCA - self.ValCB))) + " V")
  1035.  
  1036. if self.CurseurXactive == True:
  1037. #tracé des curseurs verticaux :
  1038. cr.set_dash([12,12])
  1039. cr.set_source_rgb(self.couleur_curseurX.red,self.couleur_curseurX.green,self.couleur_curseurX.blue)
  1040. cr.move_to(self.PosCursXA,10)
  1041. cr.line_to(self.PosCursXA,410)
  1042. cr.move_to(self.PosCursXB,10)
  1043. cr.line_to(self.PosCursXB,410)
  1044. cr.stroke()
  1045.  
  1046. #affichage des valeurs des curseurs verticaux :
  1047. if self.Affiche_ValCX == True:
  1048. if self.ModeYT == True:
  1049. self.ValCA = float(self.BdT)*(self.PosCursXA - (310 - 5*self.scaleBdT.get_value()))
  1050. self.ValCB = float(self.BdT)*(self.PosCursXB - (310 - 5*self.scaleBdT.get_value()))
  1051. if float(self.BdT) < 1E-6 :
  1052. self.lb_CAX.set_text(str("{:1.2f}".format(2E7*self.ValCA) + " ns"))
  1053. self.lb_CBX.set_text(str("{:1.2f}".format(2E7*self.ValCB) + " ns"))
  1054. self.lb_CdX.set_text(str("{:1.2f}".format(2E7*(self.ValCB - self.ValCA ))) + " ns")
  1055. elif float(self.BdT) < 1E-3 :
  1056. self.lb_CAX.set_text(str("{:1.2f}".format(2E4*self.ValCA)) + " " + u"\u03BC" + "s")
  1057. self.lb_CBX.set_text(str("{:1.2f}".format(2E4*self.ValCB)) + " " + u"\u03BC" + "s")
  1058. self.lb_CdX.set_text(str("{:1.2f}".format(2E4*(self.ValCB - self.ValCA))) + " " + u"\u03BC" + "s")
  1059. elif float(self.BdT) < 1 :
  1060. self.lb_CAX.set_text(str("{:1.2f}".format(20*self.ValCA) + " ms"))
  1061. self.lb_CBX.set_text(str("{:1.2f}".format(20*self.ValCB) + " ms"))
  1062. self.lb_CdX.set_text(str("{:1.2f}".format(20*(self.ValCB - self.ValCA))) + " ms")
  1063. else:
  1064. self.lb_CAX.set_text(str("{:1.2f}".format(0.02*self.ValCA) + " s"))
  1065. self.lb_CBX.set_text(str("{:1.2f}".format(0.02*self.ValCB) + " s"))
  1066. self.lb_CdX.set_text(str("{:1.2f}".format(0.02*(self.ValCB - self.ValCA))) + " s")
  1067.  
  1068. if self.ModeXY == True:
  1069. self.sensib = self.sensib1
  1070.  
  1071. self.ValCA = float(self.sensib)*(self.PosCursXA - (310 - 5*self.scaleCH1.get_value()))
  1072. self.ValCB = float(self.sensib)*(self.PosCursXB - (310 - 5*self.scaleCH1.get_value()))
  1073. if float(self.sensib) < 1 :
  1074. self.lb_CAX.set_text(str(int(20*self.ValCA)) + " mV")
  1075. self.lb_CBX.set_text(str(int(20*self.ValCB)) + " mV")
  1076. self.lb_CdX.set_text(str(int(20*(self.ValCA - self.ValCB))) + " mV")
  1077. else:
  1078. self.lb_CAX.set_text(str("{:1.2f}".format(0.02*self.ValCA) + " V"))
  1079. self.lb_CBX.set_text(str("{:1.2f}".format(0.02*self.ValCB) + " V"))
  1080. self.lb_CdX.set_text(str("{:1.2f}".format(0.02*(self.ValCB - self.ValCA))) + " V")
  1081.  
  1082. self.zone_ecran.queue_draw()
  1083.  
  1084. def on_btQuitter_clicked(self,widget):
  1085. self.fermer_port()
  1086. sleep(0.1)
  1087. Gtk.main_quit()
  1088.  
  1089. def destroy(window, self):
  1090. Gtk.main_quit()
  1091.  
  1092. def main():
  1093.  
  1094. app = RIGOLINUX()
  1095. Gtk.main()
  1096.  
  1097. if __name__ == "__main__":
  1098. sys.exit(main())
  1099.  

This site uses cookies. Some of the cookies we use are essential for parts of the site to operate and have already been set. You may delete and block all cookies from this site, but parts of the site will not work.