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, aussi appelé éthanoate 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.

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 :

Découpeuse 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 :  Une réaction d'estérification est facilement réalisable en laboratoire:

-mL d'alcool.

-gouttes d'acide sulfurique (cata)

-mL d'acide éthanoique .

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

Étape 1. Dans le réacteur de  mL, introduire un mélange équimolaire de  mol d'acide acétique et  mol d'éthanol par ouverture d'électrovanne ( à vérifier )

 Y ajouter5 mL d'acide sulfurique concentré (H2SO4(l)) et quelques grains de pierre ponce. Porter le mélange à ébullition dans un dispositif de chauffage à reflux pendant 30 minutes.

 Étape 2. Laisser refroidir le mélange réactionnel à l'air ambiant puis dans un bain d'eau froide. Verser le contenu du ballon dans une ampoule à décanter contenant environ 50 mL d'eau salée. Agiter prudemment quelques instants en dégazant régulièrement, puis éliminer la phase aqueuse.

Étape 3. Ajouter alors à la phase organique 60 mL d'une solution aqueuse d'hydrogénocarbonate de sodium (Na+(aq) + HCO3−(aq)) de concentration molaire 1 mol.L−1.

Laisser dégazer et décanter puis éliminer la phase aqueuse. Recueillir la phase organique dans un bécher.

Sécher cette phase avec du chlorure de calcium anhydre puis filtrer.

 Recueillir le filtrat dans un erlenmeyer propre et sec. Une synthèse réalisée au laboratoire en suivant ce protocole a permis d'obtenir un volume de filtrat égal à 5,9 mL.

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