Terminal RS232 :

Ce logiciel écrit en Python pour Linux est un outil d'aide au développement de logiciels pilotant des appareils connectés par la voie série (RS232).

Il permet :

 - d'envoyer des ordres (en Ascii ou en décimal) à l'appareil ;

 - de récupérer les données renvoyées par cet appareil. Selon le type de données qu'il renvoie, on pourra sélectionner le mode de visualisation adéquat : Ascii, Décimal ou Hexadécimal.

- de positionner au niveau 0 ou 1 les lignes DTR et/ou RTS

L'interface est inspirée du logiciel fourni par Philippe André dans son ouvrage "La liaison RS232" aux Editions Dunod/ETSF. (A lire pour qui souhaiterait en savoir plus sur la communication série RS232).

Ci-dessous, le logiciel en fonctionnement : une connexion a été réalisée vers l'alimentation AL991S (décrite ici). Un exemple d'ordre est réalisé :

en mode Ascii, on envoie le code R? auquel on ajoute un code de retour chariot (\r) (Cf notice de l'almentation : AL991S_Com_Protocole.pdf). L'alimentation répond en Ascii :

Capture_du_2013-04-28_001633.png

Terminal_AL991S.png

Ce logiciel m'a permis de développer plus facilement le code nécessaire à la gestion de cette alimentation. Voir la page Pilotage AL991S)

Le logiciel de communication pour la carte Quatre jauges sur USB a été également développé à l'aide du logiciel Terminal. La carte retourne 4 octets résultants de la conversion analogique-numérique réalisée sur les 4 voies d'acquisition lorsqu'elle reçoit un octet correspondant à la lettre Ascii M. On a alors intérêt dans ce type de situation à se mettre en Ascii pour la fenêtre Emission et en décimal pour la fenêtre Réception :

Capture_du_2013-04-28_001532.png

En effet, le mode Ascii en réception n'est absolument parlant pour ce cas de figure :

 

Capture_du_2013-04-28_001507.png



Le code source :

  1. #!/usr/bin/python
  2. #-*- coding: iso-8859-15 -*-
  3.  
  4. from __future__ import division
  5. from gi.repository import Gtk, GObject
  6. import os, sys
  7. import serial
  8. import string
  9. from time import sleep
  10. import glob
  11.  
  12.  
  13. class Terminal:
  14. def __init__(self):
  15.  
  16. self.builder = Gtk.Builder()
  17. self.builder.add_from_file("Terminal.glade")
  18.  
  19. #recuperation des widgets utilises par le programme :
  20. self.btOuvrir = self.builder.get_object("btOuvrir")
  21. self.btFermer = self.builder.get_object("btFermer")
  22. self.btQuitter = self.builder.get_object("btQuitter")
  23. self.btRafraichir = self.builder.get_object("btRafraichir")
  24. self.comboPort = self.builder.get_object("comboPort")
  25. self.comboBauds = self.builder.get_object("comboBauds")
  26. self.rb7bits = self.builder.get_object("rb7bits")
  27. self.rb8bits = self.builder.get_object("rb8bits")
  28. self.rbStop1 = self.builder.get_object("rbStop1")
  29. self.rbStop2 = self.builder.get_object("rbStop2")
  30. self.comboParite = self.builder.get_object("comboParite")
  31. self.swDTR = self.builder.get_object("swDTR")
  32. self.swRTS = self.builder.get_object("swRTS")
  33. self.textEmission = self.builder.get_object("textEmission")
  34. self.rb_Emission_Ascii = self.builder.get_object("rb_Emission_Ascii")
  35. self.rb_Emission_Deci = self.builder.get_object("rb_Emission_Deci")
  36.  
  37. self.btEffaceTexteEmis = self.builder.get_object("btEffaceTexteEmis")
  38. self.cb_CR = self.builder.get_object("cb_CR")
  39. self.cb_LF = self.builder.get_object("cb_LF")
  40. self.btEnvoyer = self.builder.get_object("btEnvoyer")
  41. self.textReception = self.builder.get_object("textReception")
  42. self.rb_Reception_Ascii = self.builder.get_object("rb_Reception_Ascii")
  43. self.rb_Reception_Deci = self.builder.get_object("rb_Reception_Deci")
  44. self.rb_Reception_Hexa = self.builder.get_object("rb_Reception_Hexa")
  45. self.btEffaceTexteRecu = self.builder.get_object("btEffaceTexteRecu")
  46.  
  47. self.textAide = self.builder.get_object("textAide")
  48. self.textAPropos = self.builder.get_object("textAPropos")
  49.  
  50. self.textAide = self.builder.get_object("textAide")
  51. self.textAPropos = self.builder.get_object("textAPropos")
  52.  
  53. self.buffer_aide = self.textAide.get_buffer()
  54. fichier_aide = open("Aide.txt", "r")
  55. if fichier_aide:
  56. texte_aide = fichier_aide.read()
  57. fichier_aide.close()
  58. self.buffer_aide.set_text(texte_aide)
  59.  
  60. fichier_apropos = open("A_propos.txt", "r")
  61. if fichier_apropos:
  62. texte_apropos = fichier_apropos.read()
  63. fichier_apropos.close()
  64. self.buffer_apropos = self.textAPropos.get_buffer()
  65. self.buffer_apropos.set_text(texte_apropos)
  66.  
  67. self.buffer_emission = self.textEmission.get_buffer()
  68. self.buffer_reception = self.textReception.get_buffer()
  69.  
  70. self.builder.connect_signals(self)
  71.  
  72. window = self.builder.get_object('window')
  73. window.show_all()
  74.  
  75. self.lister_ports()
  76.  
  77. #initialisations :
  78. self.sortie =""
  79. self.port_serie = " "
  80. self.port_choisi = " "
  81. self.data_format = " "
  82. self.debit = 9600
  83. self.parite = ""
  84.  
  85. self.n_data = 0
  86. self.data_deci = []
  87. self.char_ascii = []
  88. self.char_hexa = []
  89. self.liste = []
  90. self.btFermer.set_sensitive(False)
  91. self.btQuitter.set_sensitive(False)
  92. self.btEnvoyer.set_sensitive(False)
  93.  
  94. def lister_ports(self) :
  95. list_port = glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyS*')
  96. i = 0
  97. while i < len(list_port):
  98. self.comboPort.append_text(list_port[i])
  99. i=i+1
  100.  
  101. def on_btRafraichir_clicked(self,widget):
  102. #Rafraichir la liste des ports s�©rie disponibles
  103. self.comboPort.remove_all()
  104. self.lister_ports()
  105.  
  106. def on_btOuvrir_clicked(self,widget):
  107. # recuperation des parametres choisis :
  108. self.port_choisi = self.comboPort.get_active_text()
  109.  
  110. debit = self.comboBauds.get_active_text()
  111.  
  112. if self.rb8bits.get_active():
  113. data_format = serial.EIGHTBITS
  114. else:
  115. data_format = serial.SEVENBITS
  116.  
  117. if self.rbStop1.get_active():
  118. stop = serial.STOPBITS_ONE
  119. else:
  120. stop = serial.STOPBITS_TWO
  121.  
  122. if self.comboParite.get_active() == 0:
  123. parite = serial.PARITY_NONE
  124. if self.comboParite.get_active() == 1:
  125. parite = serial.PARITY_ODD
  126. if self.comboParite.get_active() == 2:
  127. parite = serial.PARITY_EVEN
  128.  
  129. try:
  130. # desactivation de widgets (ceux qui ne doivent pas
  131. # etre modifies une fois le port serie ouvert) :
  132. self.comboPort.set_sensitive(False)
  133. self.comboBauds.set_sensitive(False)
  134. self.comboParite.set_sensitive(False)
  135. self.rb7bits.set_sensitive(False)
  136. self.rb8bits.set_sensitive(False)
  137. self.rbStop1.set_sensitive(False)
  138. self.rbStop2.set_sensitive(False)
  139. self.btRafraichir.set_sensitive(False)
  140. self.btQuitter.set_sensitive(True)
  141.  
  142. #ouverture du port serie :
  143. self.port_serie = serial.Serial(
  144. port=self.port_choisi,
  145. baudrate = debit,
  146. bytesize = data_format,
  147. parity = parite,
  148. stopbits = stop,
  149. timeout=2
  150. )
  151.  
  152. #activation/desactivation de widgets :
  153. self.btFermer.set_sensitive(True)
  154. self.btEnvoyer.set_sensitive(True)
  155. self.btOuvrir.set_sensitive(False)
  156.  
  157. except :
  158.  
  159. self.comboPort.set_sensitive(True)
  160. self.comboBauds.set_sensitive(True)
  161. self.comboParite.set_sensitive(True)
  162. self.rb7bits.set_sensitive(True)
  163. self.rb8bits.set_sensitive(True)
  164. self.rbStop1.set_sensitive(True)
  165. self.rbStop2.set_sensitive(True)
  166.  
  167. self.btOuvrir.set_sensitive(True)
  168. self.btEnvoyer.set_sensitive(False)
  169. self.btRafraichir.set_sensitive(True)
  170.  
  171. #self.bt_fermer.set_sensitive(False)
  172. self.ouvert = False
  173. 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"
  174. dialog = Gtk.MessageDialog(None, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, msg)
  175. # Montre le dialog
  176. dialog.run()
  177. # Destruction du dialog
  178. dialog.destroy()
  179.  
  180. def on_swDTR_button_press_event(self,widget,event):
  181. if self.swDTR.get_active() ==True :
  182. self.port_serie.setDTR(level=1)
  183. else:
  184. self.port_serie.setDTR(level=0)
  185.  
  186. def on_swRTS_button_press_event(self,widget,event):
  187. if self.swRTS.get_active() ==True :
  188. self.port_serie.setRTS(level=1)
  189. else:
  190. self.port_serie.setRTS(level=0)
  191.  
  192.  
  193. def on_btEnvoyer_clicked(self,widget):
  194. iterdebut = self.buffer_emission.get_start_iter()
  195. iterfin = self.buffer_emission.get_end_iter()
  196. #envoi des donnees sur le port serie
  197. if (self.rb_Emission_Ascii.get_active() == True):
  198. texte_emis = self.buffer_emission.get_text(iterdebut,iterfin,True)
  199.  
  200. if (self.rb_Emission_Deci.get_active() == True):
  201. #texte_emis = (re.findall(r'\b\d+\b', self.buffer_emission.get_text(iterdebut,iterfin,True)))
  202. self.liste = [int(s) for s in self.buffer_emission.get_text(iterdebut,iterfin,True).split() if s.isdigit()]
  203. new_list = [chr(i) for i in self.liste]
  204. texte_emis = ''.join(new_list)
  205.  
  206. # avec ou sans ajout de \r et/ou \n (CR et/ou LF) :
  207. if (self.cb_CR.get_active()== False) and (self.cb_LF.get_active() == False):
  208. self.port_serie.write(texte_emis)
  209.  
  210. if (self.cb_CR.get_active()== True) and (self.cb_LF.get_active() == True) :
  211. self.port_serie.write(texte_emis + '\r' + '\n')
  212.  
  213. else :
  214. if (self.cb_CR.get_active()== True):
  215. self.port_serie.write(texte_emis + '\r' )
  216.  
  217. if self.cb_LF.get_active() == True :
  218. self.port_serie.write(texte_emis + '\n')
  219.  
  220. sleep(1)
  221.  
  222. self.data_deci = []
  223. self.char_ascii = []
  224. self.char_hexa = []
  225. self.n_data = self.port_serie.inWaiting()
  226. for i in range (self.n_data):
  227. self.data_deci.append(ord(self.port_serie.read(1)))
  228.  
  229. if self.rb_Reception_Deci.get_active() == True:
  230. texte_recu = str(self.data_deci)
  231.  
  232. if self.rb_Reception_Hexa.get_active() == True :
  233. texte_recu = ""
  234. for i in range (self.n_data):
  235. self.char_hexa.append(hex(self.data_deci[i]))
  236. texte_recu += str(self.char_hexa[i]) + " "
  237.  
  238. if self.rb_Reception_Ascii.get_active() == True:
  239. texte_recu = ""
  240. for i in range (self.n_data) :
  241. if 32 <= self.data_deci[i] <= 126:
  242. self.char_ascii.append(chr(self.data_deci[i]))
  243. else:
  244. self.char_ascii.append(".")
  245.  
  246. texte_recu += str(self.char_ascii[i])
  247.  
  248. self.buffer_reception.set_text(texte_recu)
  249.  
  250.  
  251.  
  252. def on_rb_Emission_Ascii_clicked(self,widget):
  253. self.buffer_emission.set_text('')
  254.  
  255. def on_rb_Emission_Deci_clicked(self,widget):
  256. self.buffer_emission.set_text('')
  257.  
  258. def on_rb_Reception_Hexa_clicked(self,widget):
  259. texte_recu = ""
  260. for i in range (self.n_data):
  261. self.char_hexa.append(hex(self.data_deci[i]))
  262. texte_recu += str(self.char_hexa[i]) + " "
  263. self.buffer_reception.set_text(texte_recu)
  264.  
  265. def on_rb_Reception_Deci_clicked(self,widget):
  266. texte_recu = str(self.data_deci)
  267. self.buffer_reception.set_text(texte_recu)
  268.  
  269. def on_rb_Reception_Ascii_clicked(self,widget):
  270. texte_recu = ""
  271. for i in range (self.n_data) :
  272. if 32 <= self.data_deci[i] <= 126:
  273. self.char_ascii.append(chr(self.data_deci[i]))
  274. else:
  275. self.char_ascii.append(".")
  276. texte_recu += str(self.char_ascii[i])
  277. self.buffer_reception.set_text(texte_recu)
  278.  
  279. def on_btEffaceTexteEmis_clicked(self,widget):
  280. self.buffer_emission.set_text('')
  281. self.port_serie.setDTR(level=0)
  282.  
  283.  
  284.  
  285. def on_btEffaceTexteRecu_clicked(self,widget):
  286. self.data_deci = []
  287. self.n_data = 0
  288. self.buffer_reception.set_text('')
  289.  
  290.  
  291. def on_btFermer_clicked(self,widget):
  292. #fermeture du port s�©rie ouvert
  293. try :
  294. if self.port_serie.isOpen() == True:
  295. self.port_serie.close()
  296. self.comboPort.set_sensitive(True)
  297. self.btOuvrir.set_sensitive(True)
  298. self.btRafraichir.set_sensitive(True)
  299. self.btFermer.set_sensitive(False)
  300. self.comboBauds.set_sensitive(True)
  301. self.comboParite.set_sensitive(True)
  302. self.rb7bits.set_sensitive(True)
  303. self.rb8bits.set_sensitive(True)
  304. self.rbStop1.set_sensitive(True)
  305. self.rbStop2.set_sensitive(True)
  306.  
  307. self.btEnvoyer.set_sensitive(False)
  308.  
  309.  
  310. except :
  311. msgFermer = "Erreur lors de la fermeture du port s©rie !"
  312. dlgFermer = Gtk.MessageDialog(None, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, msgFermer)
  313. dlgFermer.run()
  314. dlgFermer.destroy()
  315.  
  316. def on_btQuitter_clicked(self,widget):
  317. Gtk.main_quit()
  318.  
  319. def destroy(window, self):
  320. Gtk.main_quit()
  321.  
  322. def main():
  323. app = Terminal()
  324. Gtk.main()
  325.  
  326. if __name__ == "__main__":
  327. sys.exit(main())
  328.  

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.