ThreadSerialInput.py

# -*- coding: utf-8 -*-
##########################################################################
##                          PYTHON SOURCES                              ##
##########################################################################

#   ___|  _)  | _)       _)                         ___|
# \___ \   |  |  |   __|  |  |   |  __ `__ \       |       _ \    __|  __ \
#       |  |  |  |  (     |  |   |  |   |   |      |      (   |  |     |   |
# _____/  _| _| _| \___| _| \__,_| _|  _|  _|     \____| \___/  _|     .__/
#                                                                     _|
#Code source libre de droit. Si vous utilisez mon code, merci à vous d'en préciser la source.

#@Date : 03/11/2011
#@Auteur : Silicium Corp


import serial
import time
from threading import Thread
import Queue

class ThreadSerialInput(Thread):                                        #Class de gestion d'un thread d'envoie de données sur le port série
    isActif = False                                                     #permet de savoir si le thread est actif
    protocoleSerie = 0                                                  #initialise la variable qui va contenir le protocole serie
    shareStack = 0
#===============================================================
    def __init__(self, stackToShare, serialProtocol) :                  #Constructeur du thread : attend un objet de type Queue() et un autre de type serial.Seial()
        try :
            self.shareStack = stackToShare                              #Récupération de l'instance de la stack (Input Serial Stack)
            self.protocoleSerie = serialProtocol                        #Récupération de l'instance de la session Serial
            Thread.__init__(self)                                       #Appel du construsteur propre à l'objet Thread
        except BaseException as err :
            print("Erreur lors de la creation du thread :\n!!! %s !!!"%err)

#===============================================================
    def run (self):                                                     #méthode principale de l'objet Thread() Contenu executer lors de l'appel à thread.start()
        self.isActif = True                                             #On définie le boolean isActif à true
        while self.isActif :                                            #Tans que le boolean isActif est à true
            try :
                self.protocoleSerie.write(self.shareStack.get(True,5))  #On envoie sur le canal serie les données présentes dans la stack. Grace à .get(True,5) la récupération des datas est blocante avec un timeOut à 5 secondes
                self.shareStack.task_done()                             #Chaque fin de timeOut précédent on indique au systeme que la tache d'ecoute de la stack et pour l'instant terminée
            except:
                pass

#===============================================================
    def kill (self):                                                    #Permet d'eteindre le thread
        self.isActif = False                                            #Grace au timeout de la fonction self.shareStack.get(True, 5) on s'assure une vérification de l'etat self.isActif toutes les 5 secondes
#===============================================================
    def getIsActif (self):
        return (self.isActif)                                           #Renvoie l'etat de l'activité du thread
#===============================================================
    def __del__(self) :
        print ("- Thread Killed -")                                     #Indique juste que le thread est en fin de vie et que son destructeur a bien été appelé
#===================================================================
#====================    MAIN PRINCIPAL ============================
#===================================================================
if __name__ == "__main__":
    print ("== Main ThreadSerialInput==\n")                             #Début du programme (permet de savoir qui à lancé le programme) joue le role de Main par defaut.
    protocoleSerie = serial.Serial()                                    #Initialisation du protocole Série
    protocoleSerie.baudrate = 9600                                      #Initialisation de la vitesse du protocole 9600 BPS (Bauds per seconds)
    protocoleSerie.port = 2                                             #Initialisation du port usb/serie utilisé (2 = COM3)
    stack = Queue.LifoQueue(32)                                         #Initialisation de la pile d'envoie, (Input Serial Stack) en mode LIFO (Last In, First Out) pour garder les elements dans l'ordre

    thrd = ThreadSerialInput(stack, protocoleSerie)                     #On envoie la stack et le protocole série au thread pour sa déclaration

    try :
        protocoleSerie.open()                                           #Ouverture du dialogue série
        time.sleep(1.5)                                                 #On attend 1,5 secondes, le temps que le dialogue série s'etablisse définitivement
        thrd.start()                                                    #On active le thread
    except BaseException as err:
        print("*** Erreur lors de la connexion serie :\n!!! %s !!!"%err)

    for i in range(10) :                                                #Micro test : on envoie la lettre "e" à 10 reprises, avec 0.5 seconde d'interval.
        stack.put("e")
        time.sleep(0.5)


    thrd.kill()                                                         #Pour mettre fin au thread
    stack.join()                                                        #On s'assure que la stack n'a pas encore quelques actions à finir