Measuring Freezing Point Decrease of Water Solutions As a Way to Determine the Molecular Mass of the Solute

It is a well-known fact that the freezing temperature of water decreases if it has dissolved substances, which is why adding salt to the snow is liquefied.

This is because the approach of water molecules to form the ice crystal is hindered by the presence of molecules other than water, which causes a lower temperature to be required to solidify.

This decrease in the freezing point of a liquid due to the fact that another substance (solute) is dissolved is part of the so-called colligative properties and, in the case of diluted solutions that can be considered an ideal solution, does not depend on the nature of the solute but only on the number of particles of the same.

For dilute solutions this decrease in freezing point is described by Blagden's law.

ΔTF = KF · b · i              (Equation 1)

where:

• ΔTF, the freezing-point depression, is defined as TF1 (freezing-point pure solvent) − TF2 (freezing-point solution).
• KF, the cryoscopic constant, which is dependent on the properties of the solvent, not the solute. For water, KF = 1.853 K·kg/mol).
• b  is the molality (moles solute per kilogram of solvent).
• i  is the van 't Hoff factor (number of ion particles per formula unit of solute, e.g. i = 1 for glucose, i = 2 for NaCl and i = 3 for BaCl2).

If we consider that molecular mass (M) is defined as the weight in grams of one mole of molecules we can express the above equation in terms of molecular mass as shown below:

M = (KF · WSolute·i ) / (ΔTF ·WSolvent)               (Equation 2)

where:

· WSolute is the weight of the solute in grams

· WSolvent is the weight of the solvent in kilograms

The objective of this Instructable is:

1. Apply Equation 2 to measure the molar mass of water-soluble substances using temperature sensors controlled by an Arduino microprocessor.
2. Design a measuring cell (crioscope) that allows at least three simultaneous determinations (repetitions) of the freezing point of aqueous solutions under conditions as controlled as possible.
3. The cryoscope, which will be contained in a closed freezer, will need to emit the measured data via bluetooth outside the freezer for online analysis.
4. Design an application for cell phone using the PhyPhox app that allows to capture via bluetooth the temperature data measured by an Arduino microprocessor to be able to analyze them online.

Measuring Cell

• 3D printer (Ender-3).
• Steren PLA 3D printer filament 1.75mm White (FIL3D-020BL) and Grey (FIL3D-020GR).
• 1 Gear Motor DG01D.
• 3 Waterproof DS18B20 temperature sensor (measuring cell allows up to 5 temperature sensors).
• 3 Glass test tubes (approximately 1.5 cm in diameter and 11.5 cm long).
• 4 Neodymium Magnet Disk 10x3-3mm N35.
• 3 Butterfly clips.
• Domestic freezer (-18°C minimum temperature approximately).

Software

• Autodesk Meshmixer 3.5.474
• Autodesk 123Design 2.2.14
• Ultimaker Cura 3.4.1
• Creality Slicer 4.8.2

Arduino and Connections

• 1 Arduino Nano V3.0 CH340 with mini usb cable.
• 1 Bluetooth Low Energy BLE CC2541 Bluetooth 4.0 UART.
• 1 HG7881 (L9110) Dual Channel Motor Driver Module.
• 1 Clear breadboard (8.3 x 5.5 cm).
• 1 1k ohm resistance.
• 1 2k ohm resistance.
• 1 4.7k ohm resistance.
• Male/Male jumpers wire.
• Male/Female jumpers wire.
• 1 Terminal block pluggable, 12 position.
• 1 Portable battery charger (6000 mAh 3.7V, Output 5V, Output Max. 2.4A).
• Silicone glue.
• Plastic fasteners.
• Velcro tape.

PhyPhox App

• Cell phone (Android or iOS).
• PhyPhox app (Google Play or AppStore).

Chemicals and implements

• Distilled water (battery water "Adarga" brand).
• Sodium chloride (refined food grade sea salt "Sal Sol" brand).
• Sucrose (refined food grade cane sugar "Doña María" brand).
• Monosodium glutamate (refined food grade "Ajin-Horto Sabe Más" brand").
• 1 Portable digital weighing scale (weighing capacity - 200 g/0.01 g).
• 1 50 ml plastic container.

Measuring the freezing point of an aqueous solution is relatively simple, you just have to put a thermometer in a container containing the solution, cool by some appropriate procedure and start taking the measurements.

However, there are certain factors that cause the measurement time to increase inconveniently also affecting measurement accuracy.

One of these factors is the supercooling of the solution that causes cooling at temperatures lower than the freezing point without crystallization, thus prolonging the measurement of the freezing point that must be made at the time of crystallization itself.

Another factor is an irregular exchange of heat in the contact zone between the walls of the container where the solution is and the cooling source which delays the process of freezing the solution.

To try to minimize these factors, a measurement cell was designed and printed in 3D without walls so that the tubes were as exposed as possible to the cold environment of the freezer in order to maximize heat exchange.

This cell can accommodate up to 5 test tubes, with their corresponding temperature sensors, distributed equidistantly (for this Instructable only 3 tubes are required).

To reduce the supercooling time and maintain the composition of the solution homogeneous until the moment of crystallization, a system of blades was devised that are immersed in the solution and are moved by the action of a set of magnets moved at the same time by an electric motor.

The motor, which is controlled by the Arduino microprocessor, was programmed to activate once the solution temperature reaches 5°C.

To facilitate the capture of data and since a domestic freezer was used as a cooling source that had to be closed to maintain the temperature, the transmission via bluetooth of the data was implemented. In this way, as part of the measurement cell, a box was included that served both as a container for the Arduino microprocessor and all its components, and as a support for the measurement cell.

The files in ".STL" and ".3MF" format are included for the reproduction of the parts that constitute the measuring cell and know the parameters used to make 3D printing.

The following is the procedure for assembling the measuring cell after the corresponding components are 3D printed:

1. Assemble the piece named "Measuring Cell_Top" to the part named "Measuring Cell_Medium" using the pins arranged for this purpose. Both the pins of this part and the corresponding holes of the first previous piece have engraved labels that must correspond for a precise adjustment.
2. Assemble the assembly described in the previous point with the piece named "Measuring Cell_Bottom" using the pins arranged for that purpose. Both the pins and the corresponding holes have engraved labels that must correspond so that a precise adjustment is given.
3. Assemble the assembly described in point 2 previous with the part named "Measuring Cell_Box Lid" using the pins arranged for this purpose.
4. Assemble the assembly described in the previous point with the part named "Measuring Cell_Box Bottom" by sliding laterally the axes of the piece "Measuring Cell_Box Lid" inside the drums until the hinge formed is adjusted and pivots correctly.
5. With the help of adhesive glue the four magnets to the ends of the piece called "Magnet Rotor Wheel"
6. Once the magnets are fixed, mount the "Magnet Rotor Wheel" on the motor shaft making sure of a firm coupling.
7. Attach with a plastic fastener the motor to the piece named "Measuring Cell_Top" so that the motor shaft is centered with the axis of this piece.
8. Pass the motor wires through the hole that connects the inside of the box with the rest of the measuring cell, sealing this hole with silicone rubber.

The Arduino microprocessor and the other electronic components that make up the measurement circuit itself will be mounted in this box as shown in the figures attached to this Step.

The connections to the Arduino controller are shown in a Fritzing scheme that is attached (Cryoscopy_Arduino_3TS_MA.fzz). Also attached is the programming code of the Arduino Nano V3.0 CH340 (Cryoscopy_Arduino_3TS_MA.ino).

// Cryoscopy_3TS_ MA (Mechanical Agitator)
// Using 3 temperature sensors and an mechanical agitator
// IDE 1.8.19
// Adapted and modified by Alberto Villalobos (IDE 1.8.19)
// References:
// 1. http://hombrosdegigantes.blogspot.com
// 2. http://cetroniconline.blogspot.com/2014/07/tutorial-arduino-iv-sensor-de.html?m=1
// 3. https://randomnerdtutorials.com/guide-for-ds18b20-temperature-sensor-with-arduino/
// 4. http://diymakers.es/arduino-bluetooth/
// 5. BR010038 HG7881 (L9110) Dual Channel Motor Driver Module
//    https://www.BananaRobotics.com/shop/HG7881-(L9110)-Dual-Channel-Motor-Driver-Module
//
//  Motor connections: 
//  Arduino digital output D2 to motor driver input B-IA.
//  Arduino digital output D3 to motor driver input B-IB.
//  Motor driver VCC to operating voltage 5V.
//  Motor driver GND to common ground.
//  Motor driver MOTOR B screw terminals to a small motor.

#include <AltSoftSerial.h>
#include <OneWire.h>
#include <DallasTemperature.h>

float TempSensorSamp1;//Sample 1 Sensor
float TempSensorSamp2;//Sample 2 Sensor
float TempSensorSamp3;//Sample 3 Sensor

float TempThres = 5;//***** threshold temperatuere to activate motor *****

float CorrTempSamp1 = 0.313; //Correction to the temperature initially measured by the Sample 1 sensor
float CorrTempSamp2 = 0.188; //Correction to the temperature initially measured by the Sample 2 sensor
float CorrTempSamp3 = 0.312; //Correction to the temperature initially measured by the Sample 3 sensor

String TempData = "";

AltSoftSerial BTserial(9, 8); // RX | TX

#define ONE_WIRE_BUS 4 // Data wire is conntec to the Arduino digital pin 4
                             
OneWire oneWire(ONE_WIRE_BUS); 

DallasTemperature sensores(&oneWire);

// ***** Indicate the directions of the sensors (each DS18B20 sensor has its own code, References 1 y 2) *****

DeviceAddress Samp1 = {0x28,0xFF,0xC1,0xEA,0x64,0x15,0x02,0x61};  //Sensor 1
DeviceAddress Samp2 = {0x28,0xFF,0x59,0x8F,0x64,0x15,0x02,0xF9};  //Sensor 2
DeviceAddress Samp3 = {0x28,0xFF,0x32,0xC9,0x64,0x15,0x02,0x71};  //Sensor 3

// Motor and drive wired connections

#define HG7881_B_IA 2 // D2 --> Motor B Input A --> MOTOR B +
#define HG7881_B_IB 3 // D3 --> Motor B Input B --> MOTOR B -
 
// functional connections
#define MOTOR_B_PWM HG7881_B_IA // Motor B PWM Speed
#define MOTOR_B_DIR HG7881_B_IB // Motor B Direction
 
// the actual values for "fast" and "slow" depend on the motor

#define PWM_SLOW 50  // arbitrary slow speed PWM duty cycle
#define PWM_FAST 200 // arbitrary fast speed PWM duty cycle

void setup(void)
{
  Serial.begin(9600);
  BTserial.begin(9600);  
  sensores.begin();
  
  pinMode( MOTOR_B_DIR, OUTPUT );
  pinMode( MOTOR_B_PWM, OUTPUT );
  digitalWrite( MOTOR_B_DIR, LOW );
  digitalWrite( MOTOR_B_PWM, LOW );
}

void loop(void)
{
  sensores.requestTemperatures();

  // ***** Establish the resolution for each sensor *****
  
  //9 bits 0.50 ºC
  //10 bits 0.25 ºC
  //11 bits 0.125 ºC
  //12 bits 0.0625 ºC
  
  sensores.setResolution(Samp1,12);
  sensores.setResolution(Samp2,12);
  sensores.setResolution(Samp3,12);
  
  TempSensorSamp1 = sensores.getTempC(Samp1) + CorrTempSamp1;//Sample 1 Sensor
  TempSensorSamp2 = sensores.getTempC(Samp2) + CorrTempSamp2;//Sample 2 Sensor
  TempSensorSamp3 = sensores.getTempC(Samp3) + CorrTempSamp3;//Sample 3 Sensor

  TempData = String(String(TempSensorSamp1,3) + "/" + String(TempSensorSamp2,3) + "/" + String(TempSensorSamp3,3) + "/");

  Serial.print(TempData);Serial.println(" , ");

  BTserial.print(TempData);

  // Checks if it has reached the threshold value
  
 if (TempSensorSamp1 < TempThres or TempSensorSamp2 < TempThres or TempSensorSamp3 < TempThres)
  {

  // set the motor speed and direction
        
  digitalWrite( MOTOR_B_DIR, LOW );
  digitalWrite( MOTOR_B_PWM, HIGH );
   
  }
  else
  {
   digitalWrite( MOTOR_B_DIR, LOW );
   digitalWrite( MOTOR_B_PWM, LOW );
  } 
  delay(500); // Determines sensor data capture rate
}

DS18B20 Sensor Calibration:

It should be noted in this code that the float CorrTempSamp1, CorrTempSamp2 and CorrTempSamp3 constants are corrections that should be applied to the initial measurements of the DS18B20 temperature sensors as a calibration and that it must be determined for each individual sensor being used.

This correction is estimated by measuring the freezing point of distilled water in the measuring cell described in Step 1 using the application designed in PhyPhox described in Step 3 and the measurement procedure described in Step 4.

The deviation of 0°C, which is the freezing point value that the water must have under the measurement conditions, is the one used as a temperature sensor correction. For the three DS18B20 sensors used in this Instructable the specific corrections determined were as follows:

float CorrTempSamp1 = 0.313; //Correction to the temperature initially measured by the Sample 1 sensor
float CorrTempSamp2 = 0.188; //Correction to the temperature initially measured by the Sample 2 sensor
float CorrTempSamp3 = 0.312; //Correction to the temperature initially measured by the Sample 3 sensor

DT18B20 Addresses:

The DS18B20 temperature sensors work with OneWire technology which means that several sensors can be connected to the same digital port since each sensor has a factory code (e.g. 0x28 0x8A 0xB1 0x40 0x04 0x00 0x00 0xC7) that allows the Arduino to recognize the reading that each sensor makes independently.

This is very advantageous because it saves digital ports, especially when the project requires multiple sensors.

In our case, as seen from the Arduino circuit diagram, the three DS18B20 temperature sensors are connected to a single digital port (pin D4) which is why it is necessary to find out the particular code for each one.

To find out the address of each sensor you must assemble a circuit to read this code (DS18B20_Address.fzz), load the code DS18B20_Address.ino and test individually each sensor.

// DS1820_Address
// IDE 1.8.5
// Adapted and modified by Alberto Villalobos (IDE 1.8.5)
// References:
// 1. http://cetroniconline.blogspot.com/2014/07/tutorial-arduino-iv-sensor-de.html?m=1

#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_BUS 4
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensores(&oneWire);
DeviceAddress Sensor;

void setup(void)
{
  Serial.begin(9600);
  Serial.println("Address Sensor DS18B20:");
  sensores.begin();
  
  if (!sensores.getAddress(Sensor, 0)) 
  
  //If it is not possible to determine the address gives us an error message
    Serial.println("Unable to find sensor address.");
}

//Create the show Address function
void Mostrar_Direccion(DeviceAddress direccion)
{
  
  for (uint8_t i = 0; i < 8; i++) 
  {
    
    Serial.print("0x"); 
     if (direccion[i] < 16) Serial.print("0");
    Serial.print(direccion[i], HEX);//Usamos formato Hexadecimal
  }
}

void loop(void)
{ 
  Serial.print("Address: ");
  Mostrar_Direccion(Sensor);
  Serial.println();
  delay(5000);
}

The code or address obtained must then be separated with commas every four characters. For the three DS18B20 sensors used in this Instructable the directions determined were as follows:

DeviceAddress Samp1 = {0x28,0xFF,0xC1,0xEA,0x64,0x15,0x02,0x61};  //Sensor 1
DeviceAddress Samp2 = {0x28,0xFF,0x59,0x8F,0x64,0x15,0x02,0xF9};  //Sensor 2
DeviceAddress Samp3 = {0x28,0xFF,0x32,0xC9,0x64,0x15,0x02,0x71};  //Sensor 3

PhyPhox is an application that allows design your own Experiments using cell phone sensors, external sensors (connected via bluetooth) or both, through an online editor (Editor-Test) in which you can define relationships between the captured data, graph them and save the results.

This is the case of this Instructable in which an PhyPhox app (Cryoscopy 3TS.phyphox) was designed to measure the decrease in the freezing point of an aqueous solution (three simultaneous measurements) by adding a solute as a means of determining molecular weight as explained in Step 1.

The data were measured using an Arduino microprocessor and three waterproof DS18B20 temperature sensor.

The captured data was transmitted via bluetooth to a cell phone with the designed phyphox application installed that graphed them and allowed them to be saved in Excel format.

From the graphed information the freezing point of the solution can be determined which, together with the solution and solute weight data, will allow us to determine the molecular weight of the solute using Blagden's Law explained in Step 1.

The details of how to create a phyphox file and how to upload the program to the cell phone have already been discussed in other Instructables in which I have used this tool so I refer you to them (see Step 3 of both references) (Differential Thermal Analysis Using Arduino and PhyPhox, Measuring the Boiling Point of Liquefied Gases Using Arduino and PhyPhox).

Pro Tip 1: A simple way to understand how the online PhyPhox editor works is to load Experiments to the Editor-Test from those included in the app.

Pro Tip 2: PhyPhox is designed to use low-energy bluetooth emitters (LBE) so you need to ensure the use of this kind of device.

Before starting with the experiment, some considerations should be made regarding the practical limitations that it is normal to find when professional laboratory equipment is not available.

The first is the balance we are using, which having a nominal uncertainty of 0.01 g, will give us a much more accurate weight measurement the greater the amount of sample we weigh, however since we are going to use Blagden's law for our calculations, which is a valid approximation for ideal solutions, this is diluted, the solution we prepare can not be very concentrated.

Another consideration that should be made is that the digital thermometers used (DS18B20) although they have a measuring range between -55 ° C to + 125 ° C, their highest accuracy in measurement is between -10 ° C and +85 ° C, this being ± 0.5 ° C.  

Likewise, the maximum resolution that can be obtained with these thermometers is 12 bits, which corresponds to a temperature of 0,065 ° C.

All of the above suggests that the aqueous solutions that are prepared must meet the following requirements:

• They should not be too concentrated so as not to stray us from the scope of Blagden's law.
• The weight of the solute should be large enough to decrease the weighing error.
• The solute weight must be large enough to achieve maximum freezing point depression which decreases temperature measurement error.
• The range of temperatures in which measurements must be made should be between -10°C and 0°C to be within the scope of least measurement error.

Having made the above considerations, we proceed to describe the measurement procedure:

(Caution: This procedure involves freezing aqueous solutions in glass test tubes which could cause, depending on the intensity of the cooling, the rupture of the tube. It is recommended to wear protective gloves and glasses when handling test tubes).

1. In a plastic container of approximately 50 ml weigh between 2 and 5 g of the sample to be analyzed.
2. Bring the scale to zero and add to the container about 40 ml of distilled water noting the measured weight.
3. Shake the container until sure that the sample is completely dissolved.
4. Add to three test tubes (1.5 cm diameter and 11.5 cm length) the solution prepared in the previous step to approximately half the height.
5. Place the test tubes in the holes of the cryoscope arranged for this purpose.
6. Insert into the test tubes the stirring paddles (made using the butterfly clips) making sure that the upper end adheres to the magnets of the motor rotor.
7. Introduce the temperature sensors into the test tubes, which must be completely immersed in the solution.
8. Connect the portable battery to the cryoscope and insert the assembly into the domestic freezer that must be at the normal operating temperature close to -18 ° C.
9. Activate the Phyphox cell phone application and in the menu of the same look for the app designed and loaded for this experiment called "Cryoscopy 3TS".
10. The application will ask you to select the bluetooh emissor that was installed on the cryoscope itself that must have been previously linked on the cell phone using the normal procedure for each phone model.
11. Start the capture of information, which, if started at room temperature can last between 25 and 30 minutes, which is why it is desirable to let cool at least to 10 ° C and then start the capture.
12. A downward curve will be observed that at a certain moment will rise rapidly. The highest value that remains stable for a few seconds is recorded as freezing temperature.
13. Write down this value for each repetition and when all three have reached the freezing point activate the application menu (three vertical dots in the upper right corner) and select the option to export data that will generate files in formats to choose from that can be downloaded to the phone or sent by mail or other format.
14. Stop the application, remove the cryoscope from the refrigerator and clean thermometers, stirring paddles and tubes with running water and finally with distilled water.
15. Perform the calculations using Equation 2. If it is necessary to repeat the procedure by varying the concentration of the solution.

The designed freezing point measuring device (cryoscope) has made it possible to capture the temperature data of three samples simultaneously (triplicate), successfully transmitting the information remotely via bluetooth through the walls of the freezer to the data analysis station (cell phone) located approximately 3 m away.

The application for Phyphox designed (Cryoscopy 3TS.phyphox) has made it possible to graph the information transmitted by the cryoscope and analyze it in real time in order to measure the freezing point of the solutions contained in the test tubes. It has also allowed to export this data to Excel format in order to analyze the information later for the purposes of statistical studies, not treated in this Instructable.

The results of the application of Equation 2, derived from Blagden's law, to the data generated by various experiments are observed in the table attached to this Step.

These experiments used as solutes monosodium glutamate monohydrate, flavor enhancer used in cooking, sodium chloride and sucrose.

Of these three substances, the molecular mass determinations that most closely approximated the theoretical value were those of monosodium glutamate (deviation of 0.04%, Theor 187,260 vs. Exp. 188,01 g/mol ) and sodium chloride (deviation of 1.58%, Theor. 58,443 vs. Exp. 59,37 g/mol ) in aqueous solutions with concentrations between 6,6 and 4,3% m / m respectively.

For these same substances the deviations were higher when making the measurements at concentrations above 10% m / m (monosodium glutamate, deviation of 8.3%) and less than 1% m / m (sodium chloride, deviation of 5.6%) (see table attached to this Step).

In the case of sucrose, the deviation from the theoretical value of the molecular mass was the largest of the three substances studied. In this case for solutions of concentration between 8.2 and 16.6% m/m the deviations corresponded to 11% (Theor 342,298 vs. Exp. 304,67 g/mol) and 13.8% (Theor 342,298 vs. Exp. 295,16 g/mol) respectively.

At this point it is convenient to clarify that what is intended in this Instructable is to design an experiment that serves as a sample of concepts on the subject of cryoscopy and colligative properties, with the potential to scale to a functional instrument optimizing certain parameters.

Having made this caveat it should be noted that chemical substances used are food grade and not laboratory reagents so their purity can not be guaranteed so from the beginning it is expected more or less important deviations from the theoretical value of the molar mass.

However, it is observed that in the case of monosodium glutamate and sodium chloride the deviations of the theoretical molar mass and the measurement in this experiment is significantly low.

This was foreseeable from the beginning by the simple fact that both substances are formed by two ions so that the parameter i (number of ion particles per formula unit of solute) is equal to 2 which results in a greater temperature difference (ΔTF) per sample weight.

The other factor is that the molar mass of both substances is small which means that there are more molecules per gram of substance which also has the effect of increasing the decrease in the freezing point of the aqueous solution.

These two factors combined allow us to use more dilute solutions, which allows us to get closer to an ideal solution, and at the same time obtain higher temperature differential measurements (ΔTF) which favors a more accurate measurement.

In the case of sucrose, these factors are not so favorable since i is equal to 1 and the molar mass is between 1.8 and 5.9 times those of monosodium glutamate and sodium chloride respectively, which means fewer molecules per gram of sample.

Another factor to consider in the observed deviations is the resolution of the DS18B20 thermometers used, which, in the 12-bit mode, corresponds to 0.0625°C, which limits the measurement uncertainty to a value of approximately 0.031°C.

This forces a compromise between making a very dilute solution, to approach the range of ideal solutions but decreasing the measured ΔTF value or increasing this value by increasing the concentration of the solution and moving away from the ideal range of the Blagden's Law.

Apart from the above sources of error, the following can be noted:

• The balance used, although it could measure in the order of tenths of a gram, was not certain of its precision and accuracy, factors that could not be verified due to the lack of a calibration weight kit.
• Calibration of the temperature sensor was performed using a single point (freezing point of water) being recommended with all measuring equipment to make measurements at various temperatures and at points that cover the expected values for the samples under study.
• The heat exchange was not as efficient as expected because it was observed how the cooling curves of the three solutions did not have the same slope nor did the supercooling temperature have the same value in addition to that it occurred at very different times. This suggests that the distribution of cold air around the tubes and the mechanical agitation of the solution must be improved.

Note: This Instructable is a hobby project designed to make approximate measurements of the molecular weight of substances dissolved in water using colligative properties (freezing point decrease).

For more accurate and reliable measurements, temperature sensors should be calibrated using proven purity reference substances that cover the range of temperatures with which they are intended to work. In addition to the above, the balance used must have been calibrated using a kit of certified weights prior to use, among other technical requirements.