Supervision d’un four à tabac

7 Fév 2019 Nicolas Verrier

 

Tuteur: Stéphane BAZEILLE et Nicolas VERRIER

 

Groupe: Florian BRAUN, Noah BEAUPERE et Hugo TISSOT

 

 

Sommaire

Cahier des charges

1. Présentation générale du problème

1.1. Projet

1.2. Contexte

1.3. Énoncé du besoin

1.4. Environnement du produit

2. Expression fonctionnelle du besoin

 

Gestion et réalisation du projet

1. Simulation des capteurs

A) Générateur de fonctions arbitraires

              a) Analyse du système des valeurs recherchés
              b) Création de la fonction arbitraire
              c) Le générateur

B) Convertisseur Analogique Numérique

            a) Branchement
            b) Configuration
            c) Code

C) Avertissement visuel

            a) Branchement
            b) code

 

2. Programmation du RaspberryPI

A) Récupération des données

B) Communiquer entre les RaspberryPi

C) Analyse et utilisation des données

D) Envoie des données au serveurs

 

3. Stockage et Interprétation des Données

A) Récolte et Stockage

              a) Étude de marché
              b) Architecture

B) Accès à Distance et Interprétation

 

 

 

 

 

Cahier des charges

1.Présentation générale du produit

1.1. Projet

Le but du projet est de collecter les données de température sur chacun des fours à tabac d’une exploitation, les envoyer sur un serveur accessible depuis un smartphone ou autre pour permettre de visualiser et comparer facilement les données instantanées. Une alarme sera également créée, en cas de fort dépassement des valeurs attendues ou de problèmes matériels et l’utilisateur sera averti.

1.2. Contexte

Lors du processus de séchage du tabac, le séchage des feuilles doit passer par différents cycles avec différentes température et humidité afin d’extraire efficacement toute l’humidité. Ces cycles de séchage durent, au total, une semaine avec des fours continuellement allumés. Si un four vient à tomber en panne ou subi une anomalie durant le processus et qu’il n’y a pas de surveillance, (la nuit par exemple) les dégâts et la perte de la récolte peuvent se chiffrer en milliers d’euros.

1.3. Énonce du besoin

1.4. Environnement du produit

Le dispositif final doit pouvoir directement se connecter aux capteurs des fours et doit répondre à un minimum de contraintes environnementales:

  • résister à une température minimum de 90°C
  • résister à l’humidité ambiante

Liste du matériel:

  • 2 Raspberry Pi
  • Générateur de tension (fonction arbitraire)
  • Oscilloscope
  • CAN
  • Afficheur 7-seg
  • Relais wifi

On estime le coup total à 158€, étant donner que l’oscilloscope et le Générateur nous on été prêté.

 

2.Expression fonctionnelle du besoin

Tableau des Fonctions

Fonction Désignation Critères d’appréciations Niveau Flexibilité Observations

Limite d’accep-

tation

  

     FP1

 Permettre à l’utilisateur de consulter l’état des fours en temps réel

– visualiser sur un smartphone

– comparer les valeurs attendues et réelles

 / / /
FP2 Avertir l’utilisateur en cas de dysfonctionnement d’un four

– envoyer une notification ou mettre en place une alarme sur le smartphone

– mettre en place un avertisseur visuel

 état des alarmes récoltées toutes les 15 minutes / fréquence d’acquisition de 30s pour la simulation

 

FS1

 Récolter les données des fours – récolter les données de température et d’humidité avec les Raspberry PI données récoltées toutes les 15 minutes / fréquence d’acquisition de 30s pour la simulation
 FS2 Détecter un dysfonctionnement

– etre capable de détecter un écart de température trop grand

– réguler la température

 15minutes / régulation de la température uniquement dans la simulation
FS3 Être alimenté en énergie – branchement secteur / / /
FS4 Résister aux agressions du milieu ambiant

– résister à une haute température

– résister à l’humidité ambiante

 90°C + ou- 5°C /
FS5 Communiquer entre les Raspberry PI et le serveur

– communiquer entre la raspberry et le serveur internet

– communiquer entre les deux raspberry PI

 / / /
FS6 Respecter le budget du client -Coût final accessible 500€ + ou – 100€ /

 

 

 

Gestion et réalisation du projet

1. Simulation des capteurs

A) Générateur de fonctions arbitraires

(Tissot)

                a) Analyse du système des valeurs recherchés

On sait que les différents four à tabac possède déjà leurs propres capteurs de températures,n’ayant pas la références de ces capteur, on choisit comme référence un capteur qui correspond le plus nos besoins.

Ici on choisit donc comme référence un thermomètre à sortie analogique “THERMOSA”, avec les caractéristiques suivantes:

  • Gamme de température : -20 à +120 °C
  • Sortie analogique : Tension proportionnelle à la température -2,5 V (-20 °C) à +2,5 V (+120 °C)

On a donc 140°C sur une tension d’amplitude 5V, 1°C correspond à 0.035V.

Pour des raison pratique lié à la simulation, on affirme que 0°C correspond à une tension 0V.

 

On a pour but de créer une fonction capable de reproduire le cycle du séchage du tabac (voir courbe si-dessous).

 

La fonction devra donc obligatoirement passer par tous ces points.

On va donc avoir:

  • 1°C correspond à 0.035V
  • 20s dans la simulation correspond à 1h

On établit donc les points principaux de la fonction:

température (c°) temps simulation (s) tension de sortie (V)
32 0 1,12
40 160 1,4
40 960 1,4
57 1300 1,995
57 2400 1,995
73 2720 2,555
73 3110 2,555
40 3120 1,4
40 3280 1,4

 

                  b) Création de la fonction arbitraire

Afin de créer cette fonction, on a besoin de générer un fichier de points (CSV File). Pour le générer il existe de nombreuses solutions, ici nous allons utiliser le logiciel gratuit EasyWawe.

 

 

Pour cela, après avoir installé ce logiciel, exécutez le.

 

Une fenêtre va s’ouvrir, cliquez sur “File” puis “New”.

 

La fenêtre “Property setting” s’ouvre, dans la case “Sample” vous pouvez sélectionner le maximum de points pour avoir la meilleur précision.

 

Sélectionnez ensuite une période de 3280s, puis cliquez sur “Ok”.

 

La fenêtre “Wawe1” s’ouvre, cliquez sur “Draw” puis “Coordinate Draw”.

 

Indiquez le nombres de points nécessaire, ici “9”, et sélectionnez ensuite “Table”.

 

Rentrez ensuite les coordonnées des différents points. (ATTENTION Xpos est en kiloseconde et non en seconde).

temps simulation (s) tension de sortie (V)
0 1,12
160 1,4
960 1,4
1300 1,995
2400 1,995
2720 2,555
3110 2,555
3120 1,4
3280 1,4

 

Une fois tous les points entrés cliquez sur “Ok” et votre fonctions va être générer.

Il ne vous reste plus qu’à enregistrer en “.csv”, et vous avez votre fichier de points.

 

 

            c) Le générateur

Concernant le générateur, nous utilisons le générateur de fonctions arbitraire hameg hmf2525. Celui-ci est très pratique car il permet d’obtenir des période très longue et possède un port USB. On va donc utiliser ce port afin d’y transférer le fichier CSV précédemment créé (munissez vous de la notice de générateur si vous ne connaissez pas son fonctionnement).

Chargez le fichier

 

Réglez ensuite la période à 3280s, l’amplitude à 2.555V et l’offset à 1.25V afin que la tension de sortie corresponde à la tension souhaiter précédemment.

Il ne faut pas hésiter à utiliser un oscilloscope pour mieux visualiser la courbe.

 

 

B) Convertisseur Analogique Numérique

(Tissot)

Le CAN (Convertisseur Analogique Numérique) va nous servir à convertire la tension analogique du générateur, afin de pouvoir l’analyser sur le Raspberry PI. Le CAN possède deux entrées, on va donc y rajouter un potentiomètre pour simuler un second four.

Nous utilisons le CAN MCP 3002:

 

 

 

                a)Branchement

A l’aide d’une Breadboard, on va connecter la sortie du générateur et le potentiomètre au CAN, et le CAN au Raspberry PI comme ci dessous:

                    b) Configuration

Il faut configurer votre Raspberry PI pour utiliser le CAN.

Il faut tout d’abord vérifier que le SPI est activer.

Ouvrez un terminal et lancez la commande suivante :

sudo raspi-config

Sélectionnez « Advanced Options » puis validez :

Puis sélectionnez « SPI » puis validez :

Une fois cela fait, exécuter les commande suivante dans le terminal:

sudo apt-get install python2.7-dev

sudo apt-get install python3-dev

sudo apt-get libevent-dev

sudo pip install spidev

 

 

 

                      c) Code

#!/usr/bin/python

import time    

import spidev

DEBUG = 0

 

spi = spidev.SpiDev()

spi.open(0,0)

   

# read SPI data from MCP3002 chip

def get_adc(channel):

          # Only 2 channels 0 and 1 else return -1

          if ((channel > 1) or (channel < 0)):

                    return -1

           r = spi.xfer2([1,(2+channel)<<6,0])

           ret = ((r[1]&31) << 6) + (r[2] >> 2)

          return ret   

while 1:   

          print (get_adc(1))

         Tension = (get_adc(1)*2.7)/1024

         print (Tension)

        time.sleep(5)

 

 

Dans ce code on va créer une fonction “get_adc(channel)” qui va nous permettre de sélectionner l’entré du CAN et d’y lire la valeur. Si “channel” est différent de 0 ou 1 on retourne -1.

La valeur reçu est entre 0 et 1023, on procède alors à un calcul pour que cette valeur corresponde à une tension.

 

C) Avertissement visuel

(Tissot/Braun)

Le but est d’avertir visuellement l’utilisateur à l’aide d’un afficheur 7 segments.Il va alors pouvoir savoir sur quel four une alarme s’est déclenchée, cela peut être dû à un écart de température ou un problème matériel.

                 a) Branchement

 

Pour procéder correctement au branchement il nous faut un afficheur 7 segment et 7 résistances de 240 . Un segment va alors correspondre à un pin du Raspberry PI, il  suffit de suivre le schéma ci-dessous

Pour ma part, j’ai connecter:

  • le segment A au PIN11
  • le segment B au PIN12
  • le segment C au PIN13
  • le segment D au PIN22
  • le segment E au PIN18
  • le segment F au PIN16
  • le segment G au PIN15

 

             b) code


#librairies à importer

import time

GPIO.setmode(GPIO.BOARD)

GPIO.setwarnings(False)# On supprime les avertissements inutiles

seg={« A » : 11, « B » : 12, « C » : 13, « D » : 22, « E » : 18, « F » : 16, « G » : 15} #on indique quel segment est sur quel PIN

#fonction d’affichage

def display(x) :

GPIO.output(seg[‘A’], x in [1,4])

GPIO.output(seg[‘B’], x in [5,6])

GPIO.output(seg[‘C’], x in [2])

GPIO.output(seg[‘D’], x in [1,4,7])

GPIO.output(seg[‘E’], x in [1,3,4,5,7,9])

GPIO.output(seg[‘F’], x in [1,2,3,7])

GPIO.output(seg[‘G’], x in [0,1,7])

La fonction display va permettre de choisir quelle pin il faut allumer en fonction du nombre x. L’afficheur 7 segment étant en logique inverse on indique les nombres pour lesquels chaque segment ne doit pas s’allumer.

On intègrera donc la fonction display dans le code final.

 

2. Programmation du Raspberry PI

(Braun)

A) Récupération des données

import cantest2 #cantest2 est le programme du Convertisseur Analogique-Numérique.
Il me permet de récupérer les données à l’aide d’une fonction


def RecupTfour(Nfour) :
Tfour[Nfour] = ((cantest2.get_adc(0)*3.35)/1024)/k

Cette fonction va récupérer la température du four (Tfour), d’un four précis choisi (Nfour), il converti également la tension que le programme cantest2 me donne en une température lisible.

 

B) Communiquer entre les RaspberryPI

La communication entre les Raspberry Pi est gérée par un serveur MySQL, celui-ci sera gérer sur le Raspberry maître et l’esclave lui enverra ses données. Il faut d’abord initialiser la connexion avec MySQL :


os.system ("sudo service mysql restart")
mydb = mysql.connector.connect(  host = '192.168.xxx.xxx',
user = 'FAT',
passwd = '****',
database = 'FAT')

Cette fonctionnalité est faite par une fonction qui enverra chaque valeur au serveur qu’il pourra par la suite gérer

 

C) Analyse et utilisation des données

L’analyse des données de se fait four par four, chaque seconde.
La première étape dans l’analyse d’un four est l’initialisation de celui-ci. Pour cela, on considère que le four s’allume quand on détecte une température entre 31 et 33 °C.


 def InitialisationFour(Nfour) :
              if (Tfour[Nfour]>=31) and (cycle_start[Nfour]==0) and (Tfour[Nfour]<=33) :
                           temps_depart[Nfour] = time.time()
                           cycle_start[Nfour] = 1

A partir de ce moment, on active un timer (temps_depart) pour savoir depuis quand ce four est allumé.
Une fois le four allumé, il faut calculer la température attendue : le tabac doit sécher pendant une semaine à des paliers de température différents.


def CourbeAttendu(Nfour) :

              if (time.time()-temps_depart[Nfour]<=16) :
                          Tatt[Nfour]=32+(time.time()-temps_depart[Nfour])*0.5

              if (time.time()-temps_depart[Nfour]>16) and (time.time()-temps_depart[Nfour]<=96) : #palier 40
                         Tatt[Nfour]=40

              if (time.time()-temps_depart[Nfour]>96) and (time.time()-temps_depart[Nfour]<=130) : #montée 40-57
                         Tatt[Nfour]=40+(time.time()-temps_depart[Nfour]-96)*0.5

              if (time.time()-temps_depart[Nfour]>130) and (time.time()-temps_depart[Nfour]<=240) : #palier 57
                         Tatt[Nfour]=57

              if (time.time()-temps_depart[Nfour]>240) and (time.time()-temps_depart[Nfour]<=272) : #montée 57-73
                         Tatt[Nfour]=57+(time.time()-temps_depart[Nfour]-240)*0.5

              if (time.time()-temps_depart[Nfour]>272) and (time.time()-temps_depart[Nfour]<=312) : #palier 73
                         Tatt[Nfour]=73

              if (time.time()-temps_depart[Nfour]>312) and (time.time()-temps_depart[Nfour]<=328) : #palier 40
                         Tatt[Nfour]=40

              if (time.time()-temps_depart[Nfour]>328) :
                         Tatt[Nfour]=0
                         cycle_start[Nfour]=0
                         temps_depart[Nfour]=0

On peut voir ici que l’on a des conditions pour savoir à quel palier le four devrait se trouver.
Suivant ce palier, on définit un Tatt qui est la température théorique que le four devrait avoir à cet instant précis. Puis à la fin, quand le four a fini son cycle, on remet l’état du four (Cycle_start) à 0 pour qu’il soit considéré comme éteint et on reset son timer.


def Alarme(Nfour) :

              if (abs(Tatt[Nfour]-Tfour[Nfour])<3) :
                         temps_ecart[Nfour] = time.time()-temps_depart[Nfour]
                         alarme_ecart[Nfour] = 0
                         display(10)
             if ((time.time()-temps_depart[Nfour])-temps_ecart[Nfour]>5) :
                        #print(« ecart de temperature de plus de 5s »);
                        alarme_ecart[Nfour] = 1
                        display(Nfour)

A coté de cela, il y a une fonction alarme qui compare l’écart entre la température théorique (Tatt) et la température actuelle du four (Tfour) et actionne une alarme si cet écart dure dans le temps (5 secondes).

 

D) Envoie des données au serveurs

Une fois l’analyse des données terminée, il faut envoyer celles-ci au serveur.


def Ecriture(Nfour) :
              if (temps_different[Nfour]!=int(time.time()-temps_depart[Nfour])) :
                        date = datetime.datetime.now()
                        sql = "INSERT INTO Four_" + str(Nfour) + " VALUE (null, %s, %s, %s, %s)"
                        cur.execute(sql, (str(date), str(Tfour[i]), str(defaut[i]), str(alarme_ecart[i])))
                        mydb.commit()
                        temps_different[Nfour]=int(time.time()-temps_depart[Nfour])
                        print("four ={}, time= {}, Tatt={}, Tfour= {}, Alarme ={}".format(Nfour, int(time.time()-temps_depart[Nfour]), int(Tatt[Nfour]), int(Tfour[Nfour]),alarme_ecart[Nfour]))

Cette fonction s’occupe d’envoyer chaque donnée de chaque four au serveur et cela chaque seconde.

 

3. Stockage et Interprétation des Données

A) Récolte et Stockage

(Beaupere)

              a) Étude de marché

Avant de commencer à coder, nous avons effectué une étude de marché pour connaitre la solution technique la plus fiable, simple et peu coûteuse sur le long-terme afin de ne pas compliquer la tâche de l’utilisateur avec des maintenances ou des actions pénibles ou excessives hors de son domaine de confort.

  • Première idée : Tirer des câbles entre les capteurs et le serveur

Les câbles résistants à une utilisation extérieure sont chers et devraient être remplacés ou réparés au minimum annuellement si ce n’est plus. Un seul défaut dans le câble et toutes les données reçues jusqu’à la réparation seront inutilisables.

  • Deuxième idée : Connecter les capteurs à un micro-ordinateur possédant une liaison GSM

Il existe des services tout prêt permettant ce genre de prouesse mais malheureusement ces services sont dimensionnés pour des cas ayant plusieurs machines à superviser (comme une industrie) et serait donc un coût beaucoup trop élevé pour notre cas particulier.

  • Troisième idée : Étendre le réseau Wi-Fi jusqu’aux fours à tabac grâce à des répéteurs

Contrairement aux 2 autres solutions celle-ci n’implique qu’une simple vérification logicielle et physique des relais afin de s’assurer de leur bon fonctionnement, et dans le cas échéant le remplacement du matériel. Les facteurs d’erreurs potentielles seront les intempéries puissantes.

La solution finale a donc été le choix de la troisième idée : Étendre le réseau Wi-Fi et donc connecter 2 Raspberry Pi entre elles via le SGBD (Système de Gestion de Base de Données) MySQL.

              b) Architecture

Pour plus de clarté voici un schéma des différentes connexions :

Les 2 RaspBerry Pi sont reliées entre elles via le Wi-fi. L’un occupe la fonction de serveur MySQL et donc stockera les données ainsi que le site Web et l’autre sera la client MySQL.

Le tabaculteur accède aux données depuis son ordinateur (ou son smartphone) seulement si il est connecté en Wi-Fi.

Et voici également un schéma du trafic de données :

Chaque RaspBerry Pi possède un identifiant pour se connecter à la base de données, ainsi que le Site Web qui utilise un autre identifiant afin d’éviter des modifications non voulues.

Toutes les secondes, les données sont transmises à la base de données, 1 table pour chaque four. Une fois en situation réel, on pourra espacer la transmission des données (jusqu’à 15 minutes) vu que le processus complet dure une semaine et qu’une erreur de température n’est fatale qu’après 1 ou 2 heures.

B) Accès à Distance et Interprétation

(Beaupere)

Sur le RaspBerry Pi Serveur, nous avons codé une page a l’aide des langages de programmation Html5, CSS et PHP. Il a été pensé comme une application Web pour simplifier sa compréhension et son utilisation par le tabaculteur. Le résultat est le suivant :

Page d’accueil pour accéder aux dernières mise à jour des fours, ainsi qu’une ‘‘Led’’ de couleur verte ou rouge pour les alarmes de température ou de défaut matériel.

Page détaillé d’un four pour suivre l’avancement sur le cycle hebdomadaire. En bleu, le cycle idéal et en noir, qui apparaîtra au fur et à mesure du cycle, nous verrons le cycle actuel.

 

Vidéo de présentation

Remerciements

Merci à nos professeurs référents M. BAZEILLE et M. VERRIER et l’IUT.Lab pour le matériel.