Contrôle de Réacteur de Synthèse de l'Acétate d'Éthyle

Projet MU5CI803 - Optimisation et contrôle des procédés.

NOM et Prénom : ALIOUT Hayem / BENAMOKRANE Faiza  Soulef / BOUZIDI Manel / DJEBBAR Meriem / FERHI Abderrahmane

Introduction : 

L'acétate d'éthyle est un liquide utilisé comme solvant pour les vernis à ongles et certaines colles, en raison de sa faible nocivité et de sa volatilité importante, il est aussi utilisé dans l'industrie agroalimentaire dans certains arômes fruités.

https://www.labolycee.org/synthese-de-lacetate-dethyle

La synthèse de l'acétate d'éthyle est une réaction d'estérification relativement simple mais hautement efficace. Elle implique la réaction entre l'éthanol (alcool) et l'acide éthanoïque (acide acétique), conduisant à la formation de l'acétate d'éthyle et d'eau comme sous-produit.

CH₃CH₂OH + CH₃COOH ⇌ CH₃COOCH₂CH₃ + H₂O

Objectif du projet :

L'objectif de ce projet est de concevoir un réacteur permettant la synthèse d'acétate d'éthyle, tout en garantissant un contrôle précis de deux paramètres essentiels : la température de la réaction et le débit des réactifs.

Réactifs utilisés :

• Éthanol (alcool)
• Acide éthanoïque (acide acétique)
• Catalyseur : Généralement, aucun catalyseur n'est nécessaire pour cette réaction, car l'acide éthanoïque agit comme un catalyseur intrinsèque.

Matériel Utilisé :

• Capteur de température 
• Détecteur de niveau (Ultrasonic Rnager) (nombre à revoir )
• 2 électrovannes.
• Un breadboard.
• Une carte Arduino Uno.
• 2 modules relais.
• Tapis chauffant- Peltier- 
• X fils de connexion
• X mètre de tuyaux.
• Alimentation.
• Support

Appareils utilisés :

ImprimanteDécoupeuse 3D.Laser

Outils manuels ( Pistolets à colle, pied à coulise..)

Etapes de construction : 

Etape 1 : construction du support 

Nous avons utilisé une plaque en bois de dimension : 

Etape 2 : Mise en place des deux réservoirs ( l'un pour l'acide et l'autre pour l'alcool ) .

Les deux réservoirs utilisés en ( matière ), étaient troués pour faire passer les tuyaux d'alimentation du réacteur, que nous avons fixé ...

Etape 3 : Mise en Place des électrovannes:

Nous avons mis en place une électrovanne à la sortie des deux réservoirs.

Etape 4 : 

 

 

Mode opératoire (inclus dans les étapes je pense)

 

Codes Arduino et montage:

Détecteur de niveau : (Ultrasonic Rnager)

ultrasons ranger est un module de mesure de distance sans contact qui fonctionne à 40 KHz. Lorsque nous fournissons un signal de déclenchement d'impulsion de plus de 10 µS via la broche de signal, le Grove_Ultrasonic_Ranger émettra 8 cycles de niveau de cycle de 40 kHz et détectera l'écho. La largeur d'impulsion du signal d'écho est proportionnelle à la distance mesurée. Voici la formule : Distance = temps élevé du signal d'écho * Vitesse du son (340M/S)/2. Le signal de déclenchement et d'écho de Grove_Ultrasonic_Ranger partage 1 broche SIG.

 

Le code à copier dans l'arduino est le suivant :

#include "Ultrasonic.h"

Ultrasonic ultrasonic(7);
void setup()
{
 Serial.begin(9600);
}
void loop()
{
 long RangeInInches;
 long RangeInCentimeters;

 Serial.println("The distance to obstacles in front is: ");
 RangeInInches = ultrasonic.MeasureInInches();
 Serial.print(RangeInInches);//0~157 inches
 Serial.println(" inch");
 delay(250);

 RangeInCentimeters = ultrasonic.MeasureInCentimeters(); // two measurements should keep an interval
 Serial.print(RangeInCentimeters);//0~400cm
 Serial.println(" cm");
 delay(250);
}

Photo

Code électrovanne:

// Pin de contrôle du relais

const int relayPin = 6;

void setup() {

  // Initialise la broche de contrôle du relais en mode sortie

  pinMode(relayPin, OUTPUT);

  Serial.begin(9600);

}

void loop() {

  // Ouvre l'électrovanne pendant 5 secondes

  openValve();

  delay(5000);

  // Referme l'électrovanne

  closeValve();

  

  // Ne fait rien d'autre dans la boucle

}

void openValve() {

  // Active le relais pour alimenter l'électrovanne

  digitalWrite(relayPin, HIGH);

  Serial.println("Électrovanne ouverte");

}

void closeValve() {

  // Désactive le relais pour couper l'alimentation de l'électrovanne

  digitalWrite(relayPin, LOW);

  Serial.println("Électrovanne fermée");

}

Code Capteur de température :

// Include the libraries we need

#include <OneWire.h>

#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino

#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)

OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.

DallasTemperature sensors(&oneWire);

// arrays to hold device address

DeviceAddress insideThermometer;

/*

 * Setup function. Here we do the basics

 */

void setup(void)

{

  // start serial port

  Serial.begin(9600);

  Serial.println("Dallas Temperature IC Control Library Demo");

  // locate devices on the bus

  Serial.print("Locating devices...");

  sensors.begin();

  Serial.print("Found ");

  Serial.print(sensors.getDeviceCount(), DEC);

  Serial.println(" devices.");

  // report parasite power requirements

  Serial.print("Parasite power is: ");

  if (sensors.isParasitePowerMode()) Serial.println("ON");

  else Serial.println("OFF");

 

  // Assign address manually. The addresses below will beed to be changed

  // to valid device addresses on your bus. Device address can be retrieved

  // by using either oneWire.search(deviceAddress) or individually via

  // sensors.getAddress(deviceAddress, index)

  // Note that you will need to use your specific address here

  //insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };

  // Method 1:

  // Search for devices on the bus and assign based on an index. Ideally,

  // you would do this to initially discover addresses on the bus and then

  // use those addresses and manually assign them (see above) once you know

  // the devices on your bus (and assuming they don't change).

  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");

 

  // method 2: search()

  // search() looks for the next device. Returns 1 if a new address has been

  // returned. A zero might mean that the bus is shorted, there are no devices,

  // or you have already retrieved all of them. It might be a good idea to

  // check the CRC to make sure you didn't get garbage. The order is

  // deterministic. You will always get the same devices in the same order

  //

  // Must be called before search()

  //oneWire.reset_search();

  // assigns the first address found to insideThermometer

  //if (!oneWire.search(insideThermometer)) Serial.println("Unable to find address for insideThermometer");

  // show the addresses we found on the bus

  Serial.print("Device 0 Address: ");

  printAddress(insideThermometer);

  Serial.println();

  // set the resolution to 9 bit (Each Dallas/Maxim device is capable of several different resolutions)

  sensors.setResolution(insideThermometer, 9);

 

  Serial.print("Device 0 Resolution: ");

  Serial.print(sensors.getResolution(insideThermometer), DEC);

  Serial.println();

}

// function to print the temperature for a device

void printTemperature(DeviceAddress deviceAddress)

{

  // method 1 - slower

  //Serial.print("Temp C: ");

  //Serial.print(sensors.getTempC(deviceAddress));

  //Serial.print(" Temp F: ");

  //Serial.print(sensors.getTempF(deviceAddress)); // Makes a second call to getTempC and then converts to Fahrenheit

  // method 2 - faster

  float tempC = sensors.getTempC(deviceAddress);

  if(tempC == DEVICE_DISCONNECTED_C)

  {

    Serial.println("Error: Could not read temperature data");

    return;

  }

  Serial.print("Temp C: ");

  Serial.print(tempC);

  Serial.print(" Temp F: ");

  Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit

}

/*

 * Main function. It will request the tempC from the sensors and display on Serial.

 */

void loop(void)

{

  // call sensors.requestTemperatures() to issue a global temperature

  // request to all devices on the bus

  Serial.print("Requesting temperatures...");

  sensors.requestTemperatures(); // Send the command to get temperatures

  Serial.println("DONE");

 

  // It responds almost immediately. Let's print out the data

  printTemperature(insideThermometer); // Use a simple function to print out the data

}

// function to print a device address

void printAddress(DeviceAddress deviceAddress)

{

  for (uint8_t i = 0; i < 8; i++)

  {

    if (deviceAddress[i] < 16) Serial.print("0");

    Serial.print(deviceAddress[i], HEX);

  }

}

AVEC LED : 

#include <OneWire.h>

#include <DallasTemperature.h>

// Broche de contrôle du relais

const int relayPin = 7;

// Broche du bouton

const int buttonPin = 2;

// Broches de contrôle des LEDs

const int yellowLedPin = 8;  // Broche pour la LED jaune

const int redLedPin = 9;     // Broche pour la LED rouge

// Broche pour le capteur de température

#define ONE_WIRE_BUS 2

// Initialisation d'une instance OneWire pour communiquer avec des dispositifs OneWire

OneWire oneWire(ONE_WIRE_BUS);

// Initialisation d'une instance DallasTemperature en utilisant la référence oneWire

DallasTemperature sensors(&oneWire);

// Tableau pour stocker l'adresse du thermomètre

DeviceAddress insideThermometer;

void setup() {

  // Initialise les broches

  pinMode(relayPin, OUTPUT);

  pinMode(buttonPin, INPUT_PULLUP);

  pinMode(yellowLedPin, OUTPUT);

  pinMode(redLedPin, OUTPUT);

  // Initialise la communication série

  Serial.begin(9600);

  // Recherche des dispositifs sur le bus

  sensors.begin();

  sensors.getAddress(insideThermometer, 0);

  // Configure la résolution du capteur de température

  sensors.setResolution(insideThermometer, 9);

}

void loop() {

  // Vérifie si le bouton est enfoncé

  if (digitalRead(buttonPin) == LOW) {

    // Si le bouton est enfoncé, active l'électrovanne et mesure la température

    activateValve();

    measureTemperature();

  } else {

    // Sinon, désactive l'électrovanne et éteint les LEDs

    deactivateValve();

    digitalWrite(yellowLedPin, LOW);

    digitalWrite(redLedPin, LOW);

  }

}

void activateValve() {

  // Active le relais pour alimenter l'électrovanne

  digitalWrite(relayPin, HIGH);

  Serial.println("Électrovanne activée");

}

void deactivateValve() {

  // Désactive le relais pour couper l'alimentation de l'électrovanne

  digitalWrite(relayPin, LOW);

  Serial.println("Électrovanne désactivée");

}

void measureTemperature() {

  // Envoie une commande pour obtenir les températures depuis les capteurs

  sensors.requestTemperatures();

  

  // Obtient la température en degrés Celsius

  float tempC = sensors.getTempC(insideThermometer);

  // Allume la LED jaune si la température est inférieure à 60 degrés Celsius

  if (tempC < 60) {

    digitalWrite(yellowLedPin, HIGH);

    digitalWrite(redLedPin, LOW);

  } 

  // Allume la LED rouge si la température est supérieure à 90 degrés Celsius

  else if (tempC > 90) {

    digitalWrite(yellowLedPin, LOW);

    digitalWrite(redLedPin, HIGH);

  } 

  // Éteint toutes les LEDs si la température est entre 60 et 90 degrés Celsius

  else {

    digitalWrite(yellowLedPin, LOW);

    digitalWrite(redLedPin, LOW);

  }

  // Affiche la température

  Serial.print("Température en Celsius : ");

  Serial.println(tempC);

  

  // Attente pour éviter une lecture trop rapide

  delay(1000);

 

}

 

Journal de bord 

13 Novembre 2023 :

Choix du thème de projet et sa validation par Monsieur Pulpytel.

03 Décembre 2023 : 

Début d'assemblage du support ainsi que la modélisation du réacteur et