AI-driven Audio and Thermal HVAC Monitoring - SeeedStudio XIAO ESP32

// Connections
// XIAO ESP32C6 :
//                                Fermion: I2S MEMS Microphone
// 3.3V    ------------------------ 3V3
// D1      ------------------------ WS (+20K)
// 3.3V    ------------------------ SEL
// D0      ------------------------ SCK
// D2      ------------------------ DO (+220Ω)
//                                SSD1306 OLED Display (128x64)
// D4/SDA  ------------------------ SDA
// D5/SCL  ------------------------ SCL
//                                Control Button (A)
// D8      ------------------------ +
//                                Control Button (B)
// D9      ------------------------ +
//                                Control Button (C)
// D10     ------------------------ +
//                                Control Button (D)
// D3      ------------------------ +
//                                Arduino Nano
// RX (D7) ------------------------ TX (D4)
// TX (D6) ------------------------ RX (D2)
&
&
&
// Connections
// Arduino Nano :
//                                28BYJ-48 Stepper Motor (w/ ULN2003)
// D8      ------------------------ IN1
// D9      ------------------------ IN2
// D10     ------------------------ IN3
// D11     ------------------------ IN4
//                                Micro Switch with Pulley (JL024-2-026)
// D12     ------------------------ +
//                                Home Button
// D7     ------------------------ +
//                                5mm Common Anode RGB LED
// D3      ------------------------ R
// D5      ------------------------ G
// D6      ------------------------ B
//                                XIAO ESP32C6
// RX (D2) ------------------------ TX (D6)
// TX (D4) ------------------------ RX (D7)

// Connections
// Particle Photon 2 :
//                                MLX90641 Thermal Imaging Camera (16x12 w/ 110° FOV)
// D1 / SCL   --------------------- SCL
// D0 / SDA   --------------------- SDA
//                                ST7735 1.8" Color TFT Display
// 3.3V --------------------------- LED
// D17 / SCK  --------------------- SCK
// D15 / MOSI --------------------- SDA
// D3   --------------------------- AO (DC)
// D4   --------------------------- RESET
// D2   --------------------------- CS
// GND  --------------------------- GND
// 3.3V --------------------------- VCC
//                                COM-09032 Analog Joystick
// A0   --------------------------- VRX
// A1   --------------------------- VRY
// D19  --------------------------- SW
//                                Control Button (OK)
// D9   --------------------------- +
//                                5mm Common Anode RGB LED
// D13  --------------------------- R
// D14  --------------------------- G
// D5   --------------------------- B

# Disable sudo password.
<_username_> ALL=(ALL) NOPASSWD: ALL
daemon ALL=(ALL) NOPASSWD: ALL

	public function __init__($conn){
		$this->conn = $conn;
		// Define the Twilio account credentials and object.
		$_sid    = "<__SID__>";
        $token  = "<__ACCESS_TOKEN__>";
        $this->twilio = new Client($_sid, $token);
		// Define the user and the Twilio-verified phone numbers.
		$this->user_phone = "+____________";
		$this->from_phone = "+____________";
	}

	public function append_log_update($type, $category, $class, $date, $info){
		// Insert new system log updates (sample collections or model inference results) into the system_log MariaDB database table.
		$sql = "INSERT INTO `$this->table` (`type`, `category`, `class`, `date`, `info`)
		        VALUES ('$type', '$category', '$class', '$date', '$info')";
	    mysqli_query($this->conn, $sql);
	}

	public function optain_modify_log_updates(){
		$generated_html_elements = [];
		// Obtain all system log updates registered on the MariaDB database table — system_log.
		$sql = "SELECT * FROM `$this->table` ORDER BY `id` DESC";
		$result = mysqli_query($this->conn, $sql);
		$check = mysqli_num_rows($result);
		if($check > 0){
			while($row = mysqli_fetch_assoc($result)){
				$html_element = '';
				// Modify the fetched log updates as HTML elements according to the passed log category.
				if($row["type"] == "thermal_img" && $row["category"] == "detection"){
					$is_cooling_malfunction = ($row["class"] == "malfunction") ? '<p><i class="fa-solid fa-triangle-exclamation"></i> Cooling Malfunction Detected!</p>' : '<p><i class="fa-solid fa-circle-check"></i> Cooling Status is Stable!</p>';
					$html_element = '
										<section class="t_detection">
										<img src="generate_thermal_img/img_detection/'.$row["info"].'" />
										<h2><i class="fa-regular fa-image"></i> Thermal Image</h2>
										<p><i class="fa-solid fa-circle-info"></i> Malfunction Diagnosis</p>
										<p><i class="fa-solid fa-triangle-exclamation"></i> Anamolous Sound Detected!</p>
										'.$is_cooling_malfunction.'
										<p><i class="fa-regular fa-clock"></i> '.$row["date"].'</p>
										<div class="overlay thermal_detect"><a href="generate_thermal_img/img_detection/'.$row["info"].'" download><button><i class="fa-solid fa-cloud-arrow-down"></i></button></a></div>
										</section>
					                ';
				}else if($row["type"] == "thermal_img" && $row["category"] == "sample"){
					$html_element = '
										<section class="t_sample">
										<img src="generate_thermal_img/img_sample/'.$row["info"].'" />
										<h2><i class="fa-regular fa-image"></i> Thermal Image</h2>
										<p><i class="fa-solid fa-circle-info"></i> Sample Collection</p>
										<p><i class="fa-regular fa-clock"></i> '.$row["date"].'</p>
										<div class="overlay thermal_sample"><a href="generate_thermal_img/img_sample/'.$row["info"].'" download><button><i class="fa-solid fa-cloud-arrow-down"></i></button></a></div>
										</section>
					                ';
				}else if($row["type"] == "audio_file"){
					$html_element = '
										<section class="a_sample">
										<img src="assets/audio_icon.jpg" />
										<h2><i class="fa-solid fa-music"></i> Anamolous Sound</h2>
										<p><i class="fa-solid fa-circle-info"></i> Sample Collection</p>
										<p><i class="fa-solid fa-volume-high"></i> Class: '.$row["class"].'</p>
										<p><i class="fa-regular fa-clock"></i> '.$row["date"].'</p>
										<div class="overlay audio_sample"><a href="sample_audio_files/files/'.$row["info"].'" download><button><i class="fa-solid fa-cloud-arrow-down"></i></button></a></div>
										</section>
					                ';
				}
				// Append the most recently modified HTML element to the associated main element array so as to create a list of the generated HTML elements.
				array_push($generated_html_elements, $html_element);
			}
			// Finally, return the generated HTML element list (array).
			return $generated_html_elements;
		}else{
			return '
						<section><img src="assets/database_empty.jpg" /><h2>There are no system log updates on the database yet.</h2></section>
						<section><img src="assets/database_empty.jpg" /><h2>There are no system log updates on the database yet.</h2></section>
						<section><img src="assets/database_empty.jpg" /><h2>There are no system log updates on the database yet.</h2></section>
						<section><img src="assets/database_empty.jpg" /><h2>There are no system log updates on the database yet.</h2></section>
						<section><img src="assets/database_empty.jpg" /><h2>There are no system log updates on the database yet.</h2></section>
						<section><img src="assets/database_empty.jpg" /><h2>There are no system log updates on the database yet.</h2></section>
				   ';
		}
	}

    public function particle_register_parameter($variable){
		// Define the required authorization configurations and function arguments (POST data parameters).
		$data = "access_token=".$this->Particle["access_token"]."&args=".$variable;
		// By making a cURL call (POST request), communicate with the Particle Cloud API to activate the given Cloud function on Photon 2.
		$url = $this->Particle["API"].$this->Particle["device_id"].$this->Particle["_function"];
		$curl = curl_init();
		curl_setopt($curl, CURLOPT_POST, 1);
		curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
		curl_setopt($curl, CURLOPT_URL, $url);
		//curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
		curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
		curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
		// Execute the defined cURL call.
		$result = curl_exec($curl);
		if(!$result){ echo "Particle Cloud API => Connection Failed!"; }
		else{ echo "Particle Cloud API => Connection Successful!"; }
        curl_close($curl);
	}

    public function particle_obtain_parameter($variable){
		// By making a cURL call (GET request), communicate with the Particle Cloud API to obtain the variables registered by Photon 2.
		$url = $this->Particle["API"].$this->Particle["device_id"].$this->Particle["variables"][$variable-1]
		       ."?access_token=".$this->Particle["access_token"];
		$curl = curl_init();
		curl_setopt($curl, CURLOPT_URL, $url);
		curl_setopt($curl, CURLOPT_HEADER, false);
		curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
		curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
		// Execute the defined cURL call.
		$result = curl_exec($curl);
		if(!$result){ return "Particle Cloud API => Connection Failed!"; }
		// If the Cloud connection is successful, decode the received JSON data packet to obtain the registered value of the passed variable. Then, return the obtained value.
		else{
			$data_packet = json_decode($result);
			return $data_packet->result;
		}
        curl_close($curl);
	}

    public function particle_generate_thermal_image_from_buffers($process_type){
		// Obtain thermal imaging buffers registered on the Particle Cloud.
		$thermal_buffers = [];
		for($i=0; $i<count($this->Particle["variables"]); $i++){
			$thermal_buffers[$i] = $this->particle_obtain_parameter($i+1);
		}
		// Generate and save a thermal image from the given buffers by executing the generate_thermal_image_and_run_model.py file.
		// As executing the Python script, transmit the obtained thermal buffers and the given process type as Python Arguments.
		$path = str_replace("/assets", "/generate_thermal_img", dirname(__FILE__));
		$arguments = '--buff_1='.$thermal_buffers[0].' --buff_2='.$thermal_buffers[1].' --buff_3='.$thermal_buffers[2].' --buff_4='.$thermal_buffers[3].' --process='.$process_type;
		$run_Python = shell_exec('sudo python3 "'.$path.'/generate_thermal_image_and_run_model.py" '.$arguments.' 2>&1'); // Add 2>&1 for debugging errors directly on the browser.
		// If the passed process type is detection, obtain and return the detected thermal cooling malfunction class after running the FOMO-AD (visual anomaly detection) model via the Python script.
		// Otherwise, obtain the default sample collection response.
		return $run_Python;
	}

	public function Twilio_send_SMS($body){
		// Configure the SMS object.
        $sms_message = $this->twilio->messages
			->create($this->user_phone,
				array(
					   "from" => $this->from_phone,
                       "body" => $body
                     )
                );
		// Send the SMS.
		echo("SMS SID: ".$sms_message->sid);
	}

$server = array(
	"server" => "localhost",
	"username" => "root",
	"password" => "",
	"database" => "hvac_system_updates"
);

$conn = mysqli_connect($server["server"], $server["username"], $server["password"], $server["database"]);

include_once "class.php";

// Define the dashboard object of the dashboard class.
$dashboard = new dashboard();
$dashboard->__init__($conn);

if(isset($_GET["obtain_particle_cloud_variable"])){
	$variable_value = $dashboard->particle_obtain_parameter($_GET["obtain_particle_cloud_variable"]);
	echo $variable_value;
}

if(isset($_GET["collect_particle_cloud_variable"])){
	$dashboard->particle_register_parameter($_GET["collect_particle_cloud_variable"]);
}

if(isset($_GET["generate_cloud_thermal_image"])){
	// Generate the thermal image from the obtained (Cloud-registered) buffers.
	// If the passed process type is detection, run an inference with the Edge Impulse FOMO-AD (visual anomaly detection) model on LattePanda Mu via the same Python script.
	// Then, depending on the passed process type, obtain the response generated by the Python script.
	$python_response = $dashboard->particle_generate_thermal_image_from_buffers($_GET["generate_cloud_thermal_image"]);
	// Decode the Python script response to obtain the image tag (sample or detected label) and the creation date.
	$img_tag = explode(":", $python_response)[0];
	$date = explode(":", $python_response)[1];
	$info = $img_tag."__".$date.".jpg";
	// After generating and saving the thermal image successfully, update the system log on the MariaDB database accordingly.
	$dashboard->append_log_update("thermal_img", $_GET["generate_cloud_thermal_image"], $img_tag, $date, $info);
	// Finally, send an SMS via Twilio to inform the user of the latest system log update regarding cooling status.
	if($_GET["generate_cloud_thermal_image"] == "detection"){
		$is_cooling_malfunction = ($img_tag == "malfunction") ? "⚠️ Cooling Malfunction Detected!" : "✅ Cooling Status is Stable!";
		$message_body = "❄️ Malfunction Diagnosis ❄️"
						."\n\r\n\r⚠️ Anamolous Sound Detected!\n\r\n\r"
						.$is_cooling_malfunction
						."\n\r\n\r⏰ Date: ".$date
						."\n\r📁 🖼️ ".$info
						."\n\r\n\r💻 Please refer to the web dashboard to inspect all system log updates!"
						."\n\r\n\r🌐 http://192.168.1.21/HVAC_malfunction_diagnosis_dashboard/\n\r\n\r";
        $dashboard->Twilio_send_SMS($message_body);
	}
}

include_once "class.php";

// Define the dashboard object of the dashboard class.
$dashboard = new dashboard();
$dashboard->__init__($conn);

if(isset($_GET["new_update"])){
	$generated_html_elements = $dashboard->optain_modify_log_updates();

	// Create a JSON object from the generated HTML elements.
	$data = array("generated_html_elements" => $generated_html_elements);
	$j_data = json_encode($data);

	// Return the recently generated JSON object.
	echo($j_data);
}

include_once "../assets/class.php";

// Define the dashboard object of the dashboard class.
$dashboard = new dashboard();
$dashboard->__init__($conn);

# Get the current date and time.
$date = date("Y_m_d_H_i_s");

# Define the text file name of the received raw audio buffer (I2S).
$txt_file = "audio_%s__".$date;

// If XIAO ESP32C6 transfers the raw audio buffer (data) with the selected audio class, save the received buffer as a text (TXT) file and modify the file name accordingly.
if(isset($_GET["audio"]) && isset($_GET["class"])){
	$txt_file = sprintf($txt_file, $_GET["class"]);
}

if(!empty($_FILES["audio_sample"]["name"])){
	// Text File:
	$received_buffer_properties = array(
	    "name" => $_FILES["audio_sample"]["name"],
	    "tmp_name" => $_FILES["audio_sample"]["tmp_name"],
		"size" => $_FILES["audio_sample"]["size"],
		"extension" => pathinfo($_FILES["audio_sample"]["name"], PATHINFO_EXTENSION)
	);
    // Check whether the uploaded file's extension is in the allowed file formats.
	$allowed_formats = array('jpg', 'png', 'bmp', 'txt');
	if(!in_array($received_buffer_properties["extension"], $allowed_formats)){
		echo "FILE => File Format Not Allowed!";
	}else{
		// Check whether the uploaded file size exceeds the 5 MB data limit.
		if($received_buffer_properties["size"] > 5000000){
			echo "FILE => File size cannot exceed 5MB!";
		}else{
			// Save the uploaded file (TXT).
			move_uploaded_file($received_buffer_properties["tmp_name"], "./".$txt_file.".".$received_buffer_properties["extension"]);
			echo "FILE => Saved Successfully!";
		}
	}
	// Convert the recently saved raw audio buffer (TXT file) to a WAV audio file by executing a Python script — convert_raw_to_wav.py.
	// As executing the Python script, transmit the required audio conversion parameters for the Fermion I2S MEMS microphone as Python Arguments.
	$path = dirname(__FILE__);
	$arguments = '--nchannels=2 --sampwidth=2 --framerate=22000';
	$run_Python = shell_exec('sudo python3 "'.$path.'/convert_raw_to_wav.py" '.$arguments.' 2>&1'); // Add 2>&1 for debugging errors directly on the browser.
	// After generating the WAV audio file from the raw audio buffer, remove the converted text file from the server.
	if(file_exists("./".$txt_file.".txt")) unlink("./".$txt_file.".txt");
	// After completing the audio conversion process successfully, update the system log on the MariaDB database accordingly.
	$dashboard->append_log_update("audio_file", "sample", $_GET["class"], $date, $txt_file.".wav");
}

setInterval(function(){
	$.ajax({
		url: "./assets/dashboard_updates.php?new_update",
		type: "GET",
		success: (response) => {
			// Decode the obtained JSON object.
			const data = JSON.parse(response);
			// Assign the fetched HTML elements (sections) as the most recent system log updates to the web dashboard home (index) page.
			$(".log_updates").html(data.generated_html_elements);
			// According to the passed display option, show the associated system log updates on the dashboard — home page.
			if(current_display_option == 1){ $(".t_sample").hide(); $(".a_sample").hide(); }
			if(current_display_option == 2){ $(".t_detection").hide(); $(".a_sample").hide(); }
			if(current_display_option == 3){ $(".t_detection").hide(); $(".t_sample").hide(); }
		}
	});
}, 5000);

var current_display_option = -1;
$(".category_menu").on("click", "button", event => {
	$(".category_menu button").removeClass("active");
	$(event.target).addClass("active");
	current_display_option = event.target.id;
});

import argparse
from glob import glob
import wave
import os
from time import sleep

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("--nchannels", required=True, help="number of audio channels (1 for mono, 2 for stereo)")
    parser.add_argument("--sampwidth", required=True, help="sample width in bytes")
    parser.add_argument("--framerate", required=True, help="sampling frequency")
    args = parser.parse_args()
    nchannels = int(args.nchannels)
    sampwidth = int(args.sampwidth)
    framerate = int(args.framerate)
    # List all raw audio buffers (I2S) transferred by XIAO ESP32C6 as text (.txt) files.
    path = str(os.path.dirname(os.path.realpath(__file__)))
    buffers = glob(path + "/*.txt")
    # Then, convert the passed raw audio buffers generated by XIAO ESP32C6 (via the I2S microphone) to WAV audio files.
    for buf in buffers:
        with open(buf, "rb") as input_buf:
            raw_buffer = input_buf.read()
            file_name = buf.replace('sample_audio_files/', 'sample_audio_files/files/').replace('.txt', '.wav')
            with wave.open(file_name, "wb") as audio_file:
                audio_file.setnchannels(nchannels)
                audio_file.setsampwidth(sampwidth)
                audio_file.setframerate(framerate)
                audio_file.writeframesraw(raw_buffer)

import cv2
import numpy
from edge_impulse_linux.image import ImageImpulseRunner
import argparse
import os
import datetime
from time import sleep

    def __init__(self, model_file):
        # Get the absolute folder path to avoid errors while running this script via the web dashboard (application).
        self.path = str(os.path.dirname(os.path.realpath(__file__)))
        # Define the required configurations to run the Edge Impulse FOMO-AD (visual anomaly detection) model.
        self.model_file = os.path.join(self.path, model_file).replace("/generate_thermal_img", "")
        self.threshold = 5
        self.detected_class = ""
        self.__debug = False
        # Define the required variables to generate a thermal image from the given thermal scan (imaging) buffers.
        self.t_img = {"w": 192, "h": 192, "p_w": 6, "p_h": 8, "temp_img": self.path+"/thermal_template.jpg"}
        self.thermal_buff_width = 16
        self.thermal_buff_height = 12

    def generate_thermal_img(self, thermal_buff):
        # Get the template (blank) thermal image (192 x 192).
        template = cv2.imread(self.t_img["temp_img"])
        # Generate the thermal image from the given buffers ((16x12) x 4).
        p_num = 1
        for t in range(len(thermal_buff)):
            # Define buffer starting points.
            if(t==0): img_x, img_x_s, img_y, img_y_s = 0, 0, 0, 0
            if(t==1): img_x, img_x_s, img_y, img_y_s = int(self.t_img["w"]/2), int(self.t_img["w"]/2), 0, 0
            if(t==2): img_x, img_x_s, img_y, img_y_s = 0, 0, int(self.t_img["h"]/2), int(self.t_img["h"]/2)
            if(t==3): img_x, img_x_s, img_y, img_y_s = int(self.t_img["w"]/2), int(self.t_img["w"]/2), int(self.t_img["h"]/2), int(self.t_img["h"]/2)
            for p in thermal_buff[t]:
                # Draw individual data points of each thermal buffer with the color indicator estimated by the specific color algorithm based on the defined temperature ranges to generate a precise thermal image.
                # Note: Indicators are defined in the BGR format.
                match p:
                    case 'w':
                        cv2.rectangle(template, (img_x,img_y), (img_x+self.t_img["p_w"],img_y+self.t_img["p_h"]), (255,255,255), -1)
                    case 'c':
                        cv2.rectangle(template, (img_x,img_y), (img_x+self.t_img["p_w"],img_y+self.t_img["p_h"]), (255,255,0), -1)
                    case 'b':
                        cv2.rectangle(template, (img_x,img_y), (img_x+self.t_img["p_w"],img_y+self.t_img["p_h"]), (255,0,0), -1)
                    case 'y':
                        cv2.rectangle(template, (img_x,img_y), (img_x+self.t_img["p_w"],img_y+self.t_img["p_h"]), (0,255,255), -1)
                    case 'o':
                        cv2.rectangle(template, (img_x,img_y), (img_x+self.t_img["p_w"],img_y+self.t_img["p_h"]), (0,165,255), -1)
                    case 'r':
                        cv2.rectangle(template, (img_x,img_y), (img_x+self.t_img["p_w"],img_y+self.t_img["p_h"]), (0,0,255), -1)
                # Update the successive data point coordinates.
                img_x += self.t_img["p_w"]
                if(p_num==self.thermal_buff_width):
                    img_x = img_x_s
                    img_y += self.t_img["p_h"]
                    p_num = 0
                p_num += 1
        # After generating the thermal image, register the modified frame before saving an image file.
        self.generated_thermal_image = template

    def save_thermal_img(self, img_tag, _type):
        # Depending on the passed process type (sample or detection), save the produced (registered) frame to the img_sample or img_detection folder by adding the creation date to the file name.
        folder = "img_sample" if _type=="sample" else "img_detection"
        date = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
        file_name = "{}/{}/{}__{}.jpg".format(self.path, folder, img_tag, date)
        cv2.imwrite(file_name, self.generated_thermal_image)
        print(img_tag+":"+date)

    def run_inference(self, process):
        # Run inference to identify HVAC cooling malfunctions based on the generated thermal images via visual anomaly detection.
        with ImageImpulseRunner(self.model_file) as runner:
            try:
                resulting_image = ""
                # Print the information of the Edge Impulse FOMO-AD model converted to a Linux (x86_64) application (.eim).
                model_info = runner.init()
                if(self.__debug): print('\nLoaded runner for "' + model_info['project']['owner'] + ' / ' + model_info['project']['name'] + '"')
                labels = model_info['model_parameters']['labels']
                # Get the latest registered thermal image (frame) generated from the passed thermal imaging buffers.
                latest_img = self.generated_thermal_image
                # After obtaining the latest image, resize (if necessary) and generate features from the retrieved frame depending on the provided model so as to run an inference.
                features, cropped = runner.get_features_from_image(latest_img)
                res = runner.classify(features)
                # Since the Edge Impulse FOMO-AD (visual anomaly detection) model categorizes given image samples by individual cells (grids)
                # based on the dichotomy between two predefined classes (anomaly and no anomaly), utilize the mean visual anomaly value to detect overall (high-risk) thermal cooling malfunctions.
                if res["result"]["visual_anomaly_mean"] >= self.threshold:
                    # If the given thermal image sample indicates a thermal cooling malfunction:
                    self.detected_class = "malfunction"
                    # Obtain the cells with their assigned labels and anomaly scores evaluated by the FOMO-AD (visual anomaly detection) model.
                    intensity = ""
                    c_offset = 5
                    for cell in res["result"]["visual_anomaly_grid"]:
                        # Draw each cell assigned with an anomaly score greater than the given model threshold on the resulting image.
                        if cell["label"] == "anomaly" and cell["value"] >= self.threshold:
                            cv2.rectangle(cropped, (cell["x"], cell["y"]), (cell["x"]+cell["width"], cell["y"]+cell["height"]), (0,255,0), 2)
                            # According to the given threshold, calculate the anomaly intensity level — Low (L), Moderate (M), High (H) — for each individual cell provided by the FOMO-AD model.
                            if(cell["value"] >= self.threshold and cell["value"] < self.threshold+c_offset):
                                intensity = "L"
                            elif(cell["value"] >= self.threshold+c_offset and cell["value"] < self.threshold+(2*c_offset)):
                                intensity = "M"
                            elif(cell["value"] >= self.threshold+(2*c_offset)):
                                intensity = "H"
                            # Then, draw the estimated anomaly intensity level to the top-left corner of the passed cell.
                            cv2.putText(cropped, intensity, (cell["x"]+2, cell["y"]+10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0,255,0), 1, cv2.LINE_AA)
                else:
                    # If the given thermal image sample indicates a stable cooling process:
                    self.detected_class = "normal"
                # Save the generated model resulting image modified with the passed cells and their evaluated anomaly intensity levels (if applicable) to the img_detection folder on the web dashboard.
                if self.detected_class != "":
                    if(self.__debug): print("\nFOMO-AD Model Detection Result => " + self.detected_class + "\n")
                    self.generated_thermal_image = cropped
                    self.save_thermal_img(self.detected_class, process)
            # Stop the running inference.
            finally:
                if(runner):
                    runner.stop()

thermal_img = thermal_img("model/ai-driven-hvac-fault-diagnosis-(thermal)-linux-x86_64-v1.eim")

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("--buff_1", required=True, help="thermal image buffer (16x12)")
    parser.add_argument("--buff_2", required=True, help="thermal image buffer (16x12)")
    parser.add_argument("--buff_3", required=True, help="thermal image buffer (16x12)")
    parser.add_argument("--buff_4", required=True, help="thermal image buffer (16x12)")
    parser.add_argument("--process", required=True, help="1) sample=only generate thermal image to collect data 2) detection=generate thermal image and run an inference")
    args = parser.parse_args()
    buff_1 = args.buff_1
    buff_2 = args.buff_2
    buff_3 = args.buff_3
    buff_4 = args.buff_4
    process = args.process
    # After obtaining the required parameters via Python Arguments, generate a thermal image from the given thermal imaging buffers.
    thermal_img.generate_thermal_img([buff_1, buff_2, buff_3, buff_4])
    # Depending on the passed process type (sample or detection), run an inference with the Edge Impulse FOMO-AD (visual anomaly detection) model
    # to diagnose cooling malfunctions or save the produced thermal image directly as a sample.
    if(process=="detection"):
        thermal_img.run_inference(process)
    elif(process=="sample"):
        thermal_img.save_thermal_img(process, process)

CREATE TABLE `system_log`(
	id int AUTO_INCREMENT PRIMARY KEY NOT NULL,
	type varchar(255),
    category varchar(255),
    class varchar(255),
    `date` varchar(255),
    info varchar(255)
);

// XIAO ESP32C6 :
//
// Define the assigned interface logo information as arrays.
PROGMEM static const unsigned char *interface_logos[] = {home_bits, audio_bits, faulty_audio_bits, cnc_pos_bits};
int interface_widths[] = {home_width, audio_width, faulty_audio_width, cnc_pos_width};
int interface_heights[] = {home_height, audio_height, faulty_audio_height, cnc_pos_height};
//
display.drawBitmap(0, (SCREEN_HEIGHT-l_h)/2, interface_logos[menu_option], l_w, l_h, SSD1306_WHITE);
&
&
&
// Particle Photon 2 :
//
// Define the assigned interface logo information as arrays.
PROGMEM static const unsigned char *interface_logos[] = {home_bits, scan_bits, inspect_bits};
int interface_widths[] = {home_width, scan_width, inspect_width};
int interface_heights[] = {home_height, scan_height, inspect_height};
//
st7735.drawBitmap((SCREEN_WIDTH-interface_widths[i_x])/2, (SCREEN_HEIGHT-interface_heights[i_x])/2, interface_logos[i_x], interface_widths[i_x], interface_heights[i_x], _menu.scan_c);

#include <WiFi.h>
#include <driver/i2s.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#include "logo.h"

char server[] = "192.168.1.21";
// Define the web application (HVAC malfunction dashboard) path.
String application = "/HVAC_malfunction_diagnosis_dashboard/";

// Initialize the WiFiClient object.
WiFiClient client; /* WiFiSSLClient client; */

#define I2S_SCK    D0
#define I2S_WS     D1
#define I2S_DO     D2
#define DATA_BIT   (16) //16-bit
// Define the I2S processor port.
#define I2S_PORT I2S_NUM_0

#define SCREEN_WIDTH 128  // OLED display width, in pixels
#define SCREEN_HEIGHT 64  // OLED display height, in pixels
#define OLED_RESET    -1  // Reset pin # (or -1 if sharing Arduino reset pin)

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void i2s_install(uint32_t sampling_rate){
  // Configure the I2S processor port for the I2S microphone (ONLY_RIGHT).
  const i2s_config_t i2s_config = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = sampling_rate,
    .bits_per_sample = (i2s_bits_per_sample_t)DATA_BIT,
    .channel_format = I2S_CHANNEL_FMT_ONLY_RIGHT,
    .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_STAND_I2S),
    .intr_alloc_flags = 0,
    .dma_buf_count = 16,
    .dma_buf_len = audio_buff_size,
    .use_apll = false
  };

  i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
}

void i2s_setpin(){
  // Set the I2S microphone pin configurations.
  const i2s_pin_config_t pin_config = {
    .bck_io_num = I2S_SCK,
    .ws_io_num = I2S_WS,
    .data_out_num = -1,
    .data_in_num = I2S_DO
  };

  i2s_set_pin(I2S_PORT, &pin_config);
}

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, pass);
  // Attempt to connect to the given Wi-Fi network.
  while(WiFi.status() != WL_CONNECTED){
    // Wait for the network connection.
    delay(500);
    Serial.print(".");
  }
  // If connected to the network successfully:
  Serial.println("Connected to the Wi-Fi network successfully!");

  if(!digitalRead(control_button_A)){
    menu_option-=1;
    if(menu_option < 0) menu_option = 3;
    delay(500);
  }
  if(!digitalRead(control_button_C)){
    menu_option+=1;
    if(menu_option > 3) menu_option = 0;
    delay(500);
  }

void show_interface(String com, int menu_option){
  // Get the assigned interface logo information.
  int l_w = interface_widths[menu_option];
  int l_h = interface_heights[menu_option];
  if(com == "home"){
    display.clearDisplay();
    display.drawBitmap(0, (SCREEN_HEIGHT-l_h)/2, interface_logos[menu_option], l_w, l_h, SSD1306_WHITE);
    display.setTextSize(1);
    (menu_option == 1) ? display.setTextColor(SSD1306_BLACK, SSD1306_WHITE) : display.setTextColor(SSD1306_WHITE);
    display.setCursor(l_w+5, 5); display.println("Collect Audio");
    (menu_option == 2) ? display.setTextColor(SSD1306_BLACK, SSD1306_WHITE) : display.setTextColor(SSD1306_WHITE);
    display.setCursor(l_w+5, 20); display.println("Faulty Sound");
    (menu_option == 3) ? display.setTextColor(SSD1306_BLACK, SSD1306_WHITE) : display.setTextColor(SSD1306_WHITE);
    display.setCursor(l_w+5, 35); display.println("CNC Positioning");
    display.setCursor(l_w+5, 45); display.println("&Thermal Buffer");
    display.setCursor(l_w+5, 55); display.println("Collection");
    display.display();
  }else if(com == "collect"){
    int l_offset = 1;
    display.clearDisplay();
    display.drawBitmap((SCREEN_WIDTH-l_w)/2, l_offset, interface_logos[menu_option], l_w, l_h, SSD1306_WHITE);
    display.setTextSize(1);
    display.setCursor((SCREEN_WIDTH/2)-45, (2*l_offset)+l_h+5);
    display.println("[A] => normal");
    display.setCursor((SCREEN_WIDTH/2)-45, (8*l_offset)+l_h+15);
    display.println("[C] => defective");
    display.display();
  }else if(com == "CNC"){
    int l_offset = 2, h_offset = 16;
    // Depending on the status of the CNC positioning point (Waiting, Ongoing, Saved, or Image Ready), display the associated CNC status icon on the screen.
    int i_1 = _CNC.pos_status[0], i_2 = _CNC.pos_status[1], i_3 = _CNC.pos_status[2], i_4 = _CNC.pos_status[3];
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(l_offset, l_offset); display.println("Position [1] =>");
    display.drawBitmap(SCREEN_WIDTH-CNC_widths[i_1]-l_offset, l_offset, CNC_logos[i_1], CNC_widths[i_1], CNC_heights[i_1], SSD1306_WHITE);
    display.setCursor(l_offset, l_offset + h_offset); display.println("Position [2] =>");
    display.drawBitmap(SCREEN_WIDTH-CNC_widths[i_2]-l_offset, l_offset+h_offset, CNC_logos[i_2], CNC_widths[i_2], CNC_heights[i_2], SSD1306_WHITE);
    display.setCursor(l_offset, l_offset + (2*h_offset)); display.println("Position [3] =>");
    display.drawBitmap(SCREEN_WIDTH-CNC_widths[i_3]-l_offset, l_offset+(2*h_offset), CNC_logos[i_3], CNC_widths[i_3], CNC_heights[i_3], SSD1306_WHITE);
    display.setCursor(l_offset, l_offset + (3*h_offset)); display.println("Position [4] =>");
    display.drawBitmap(SCREEN_WIDTH-CNC_widths[i_4]-l_offset, l_offset+(3*h_offset), CNC_logos[i_4], CNC_widths[i_4], CNC_heights[i_4], SSD1306_WHITE);
    display.display();
  }else if(com == "run"){
    int l_c_w = class_widths[predicted_class], l_c_h = class_heights[predicted_class], l_offset = 2;
    String p_c = "[ "+classes[predicted_class]+" ]"; p_c.toUpperCase();
    int p_c_l = p_c.length()*5;
    display.clearDisplay();
    display.drawBitmap((SCREEN_WIDTH-l_c_w)/2, l_offset, class_logos[predicted_class], l_c_w, l_c_h, SSD1306_WHITE);
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor((SCREEN_WIDTH-p_c_l)/2, SCREEN_HEIGHT-(6*l_offset)); display.println(p_c);
    display.display();
  }
}

bool microphone_sample(bool _debug){
  // Obtain the information generated by the I2S microphone and save it to the input buffer — sample_audio_buffer.
  size_t bytesIn = 0;
  esp_err_t result = i2s_read(I2S_PORT, &sample_audio_buffer, audio_buff_size, &bytesIn, portMAX_DELAY);
  // If the I2S microphone generates raw audio data successfully:
  if(result == ESP_OK){
    Serial.println("\nAudio Data Generated Successfully!");
    // Depending on the given model, scale (resize) the raw audio buffer (data) collected by the I2S microphone. Otherwise, the sound might be too quiet for classification.
    for(int x = 0; x < bytesIn/2; x++){
      sample_audio_buffer[x] = (int16_t)(sample_audio_buffer[x]) * 8;
    }
    // If requested, display the average (mean) audio data reading on the serial plotter.
    if(_debug){
      int16_t samples_read = bytesIn / 8;
      if(samples_read > 0){
        float mean = 0;
        for(int16_t i = 0; i < samples_read; ++i){ mean += (sample_audio_buffer[i]); }
        mean /= samples_read;
        Serial.println(mean);
      }
    }
    // Exit.
    return true;
  }else{
    Serial.println("\nAudio Data Collection Failed!");
    // Exit.
    return false;
  }
}

boolean make_a_post_request(String request){
  // Connect to the web application named HVAC_malfunction_diagnosis_dashboard. Change '80' with '443' if you are using SSL connection.
  if(client.connect(server, 80)){
    // If successful:
    Serial.println("\nConnected to the web application successfully!\n");
    // Create the query string:
    String query = application + request;
    // Make an HTTP POST request:
    String head = "--AudioSample\r\nContent-Disposition: form-data; name=\"audio_sample\"; filename=\"new_sample.txt\";\r\nContent-Type: text/plain;\r\n\r\n";
    String tail = "\r\n--AudioSample--\r\n";
    // Get the total message length.
    uint32_t totalLen = head.length() + audio_buff_size*buf_multiplier + tail.length();
    // Start the request:
    client.println("POST " + query + " HTTP/1.1");
    client.println("Host: 192.168.1.21");
    client.println("Content-Length: " + String(totalLen));
    client.println("Connection: Keep-Alive");
    client.println("Content-Type: multipart/form-data; boundary=AudioSample");
    client.println();
    client.print(head);
    // According to the given buffer multiplier, collect and transfer I2S raw audio buffers consecutively to prevent memory allocation issues.
    for(int t=0; t<buf_multiplier; t++){
      microphone_sample(false);
      for(int i=0; i<audio_buff_size; i++) client.print(sample_audio_buffer[i]);
    }
    // Complete data (buffer) writing.
    client.print(tail);
    // Wait until transferring the generated (multiplied) raw audio sample.
    delay(5000);
    // If successful:
    Serial.println("HTTP POST => Data transfer completed!\n");
    return true;
  }else{
    Serial.println("\nConnection failed to the web application!\n");
    delay(2000);
    return false;
  }
}

  if(menu_option == 1 && !digitalRead(control_button_B)){
    option_update = true;
    while(option_update){
      // Inform the user of the data collection settings.
      int l_offset = 5;
      show_interface("collect", menu_option);
      delay(2000);
      // According to the pressed control button (A or C), generate an audio sample from the collected raw audio buffers
      // and transfer the generated sample with the selected audio class to the web dashboard (application).
      if(!digitalRead(control_button_A) || !digitalRead(control_button_C)){
        // Get the selected audio class.
        String selected_class = (!digitalRead(control_button_A)) ? "normal" : "defective";
        // Before proceeding with generating an audio sample, check the I2S microphone status.
        if(microphone_sample(false)){
          // After collecting data successfully, notify the user via the screen.
          display.clearDisplay();
          display.drawBitmap((SCREEN_WIDTH-collected_width)/2, l_offset, collected_bits, collected_width, collected_height, SSD1306_WHITE);
          display.setTextSize(1);
          display.setCursor(0, collected_height+(2*l_offset));
          display.println("I2S microphone\ncollecting data!");
          display.display();
          delay(3000);
          // If the I2S microphone is operating precisely, generate a one-second audio sample by utilizing the buffer multiplier.
          // Simultaneously, transfer the collected raw data buffers to the web dashboard (application) while making an HTTP POST request in order to avoid memory allocation errors.
          if(make_a_post_request("sample_audio_files/save_audio_sample.php?audio=new&class="+selected_class)){
            // If successful:
            display.clearDisplay();
            display.drawBitmap((SCREEN_WIDTH-connected_width)/2, l_offset, connected_bits, connected_width, connected_height, SSD1306_WHITE);
            display.setTextSize(1);
            display.setCursor(0, connected_height+(2*l_offset));
            display.println("Sample Transferred\nSuccessfully!");
            display.display();
            delay(5000);
          }else{
            display.clearDisplay();
            display.drawBitmap((SCREEN_WIDTH-error_width)/2, l_offset, error_bits, error_width, error_height, SSD1306_WHITE);
            display.setTextSize(1);
            display.setCursor(0, error_height+(2*l_offset));
            display.println("Server => Connection\nFailed!");
            display.display();
            delay(5000);
          }
        }else{
          display.clearDisplay();
          display.drawBitmap((SCREEN_WIDTH-error_width)/2, l_offset, error_bits, error_width, error_height, SSD1306_WHITE);
          display.setTextSize(1);
          display.setCursor(0, error_height+(2*l_offset));
          display.println("Sample Collection\nFailed!");
          display.display();
          delay(3000);
        }
      }
      // If the control button D is pressed, redirect the user to the home screen.
      if(!digitalRead(control_button_D)){
        option_update = false;
      }
    }
  }

#include <SoftwareSerial.h>
#include <Stepper.h>

int stepsPerRevolution = 2038, max_motor_RPM = 10, step_delay = 500, CNC_go_to_switch = 15, CNC_switch_to_home = 1;
Stepper CNC_motor(stepsPerRevolution, 8, 10, 9, 11); // IN1-IN3-IN2-IN4

const int rxPin = 2, txPin = 4;
SoftwareSerial XIAO(/*RX=*/rxPin, /*TX=*/txPin);

struct _CNC{
  String pos_command[5] = {"1", "2", "3", "4", "h"};
  int step_number[4] = {1, 1, 3, 1};
  int pos_delay = 5000;
};

XIAO.begin(115200);

int CNC_motor_move(int step_number, String _direction){
  int revs = 0;
  // Move the CNC stepper motor according to the passed step number and the direction.
  // CW:  Clockwise
  // CCW: Counter-clockwise
  if(_direction == "CW"){
    for(int i=0; i<step_number; i++){
      CNC_motor.setSpeed(max_motor_RPM/2);
      CNC_motor.step(stepsPerRevolution/8);
      delay(step_delay);
      revs++;
    }
  }else if(_direction == "CCW"){
    for(int i=0; i<step_number; i++){
      CNC_motor.setSpeed(max_motor_RPM/2);
      CNC_motor.step(-stepsPerRevolution/4);
      delay(step_delay);
      revs++;
      // If the thermal camera container head triggers the stop micro switch by colliding, force the container head to return to the home position.
      if(digitalRead(CNC_stop_switch)){
        if(CNC_position_home()) adjustColor(255,255,255);
        break;
      }
    }
  }
  // Return the total revolution number.
  return revs;
}

bool CNC_position_home(){
  // Return the thermal camera container head to the home position — 0.
  for(int i=0; i<CNC_switch_to_home; i++){
    CNC_motor.setSpeed(max_motor_RPM);
    CNC_motor.step(stepsPerRevolution/8);
    delay(step_delay);
  }
  return true;
}

  if(XIAO.available() > 0){
    data_packet = XIAO.readString();
  }

  if(data_packet != ""){
    Serial.print("Received Data Packet => "); Serial.println(data_packet);
    // Depending on the received coordinate update command from XIAO ESP32C6, change the thermal camera container head position via the stepper motor.
    if(data_packet.indexOf(_CNC.pos_command[0]) > -1){
      adjustColor(255,0,0);
      CNC_motor_move(_CNC.step_number[0], "CW");
      adjustColor(255,255,0);
      delay(_CNC.pos_delay);
      // Transfer (reply) the coordinate update confirmation message to XIAO ESP32C6 via serial communication.
      XIAO.print("CNC_OK");
      delay(1000);
      adjustColor(0,255,0);
    }else if(data_packet.indexOf(_CNC.pos_command[1]) > -1){
      adjustColor(255,0,0);
      CNC_motor_move(_CNC.step_number[1], "CW");
      adjustColor(255,255,0);
      delay(_CNC.pos_delay);
      // Transfer (reply) the coordinate update confirmation message to XIAO ESP32C6 via serial communication.
      XIAO.print("CNC_OK");
      delay(1000);
      adjustColor(0,255,0);
    }else if(data_packet.indexOf(_CNC.pos_command[2]) > -1){
      adjustColor(255,0,0);
      CNC_motor_move(_CNC.step_number[2], "CW");
      adjustColor(255,255,0);
      delay(_CNC.pos_delay);
      // Transfer (reply) the coordinate update confirmation message to XIAO ESP32C6 via serial communication.
      XIAO.print("CNC_OK");
      delay(1000);
      adjustColor(0,255,0);
    }else if(data_packet.indexOf(_CNC.pos_command[3]) > -1){
      adjustColor(255,0,0);
      CNC_motor_move(_CNC.step_number[3], "CW");
      adjustColor(255,255,0);
      delay(_CNC.pos_delay);
      // Transfer (reply) the coordinate update confirmation message to XIAO ESP32C6 via serial communication.
      XIAO.print("CNC_OK");
      delay(1000);
      adjustColor(0,255,0);
    }else if(data_packet.indexOf(_CNC.pos_command[4]) > -1){
      // If requested, after going through four coordinate updates, return the thermal camera container head to the starting point (zeroing).
      int zeroing = 0;
      for(int i=0; i<4; i++) zeroing+=_CNC.step_number[i];
      Serial.print("Zeroing the container head for "); Serial.print(zeroing); Serial.println(" steps!\n");
      adjustColor(255,0,0);
      CNC_motor_move(zeroing, "CCW");
      adjustColor(255,255,0);
      delay(_CNC.pos_delay);
      // Transfer (reply) the coordinate update confirmation message to XIAO ESP32C6 via serial communication.
      XIAO.print("CNC_OK");
      delay(1000);
      adjustColor(255,0,255);
    }
    // Clear the received data packet.
    data_packet = "";
  }

  if(!digitalRead(CNC_home_button)){
    Serial.println("\nHoming sequence activated!\n");
    adjustColor(0,0,255);
    CNC_motor_move(CNC_go_to_switch, "CCW");
  }

struct _CNC{
  String pos_command[5] = {"111111111", "222222222", "333333333", "444444444", "hhhhhhhhh"};
  int pos_status[4] = {4, 4, 4, 4};
  boolean serial_update = false;
};

Serial1.begin(115200, SERIAL_8N1, /*RX=*/D7,/*TX=*/D6);

boolean make_a_get_request(String request){
  // Connect to the web application named HVAC_malfunction_diagnosis_dashboard. Change '80' with '443' if you are using SSL connection.
  if(client.connect(server, 80)){
    // If successful:
    Serial.println("\nConnected to the web application successfully!\n");
    // Create the query string:
    String query = application + request;
    // Make an HTTP GET request:
    client.println("GET " + query + " HTTP/1.1");
    client.println("Host: 192.168.1.21");
    client.println("Connection: close");
    client.println();
    // Wait until completing the request process.
    delay(2000);
    // If successful:
    Serial.println("HTTP GET => Connection established!\n");
    return true;
  }else{
    Serial.println("\nConnection failed to the web application!\n");
    delay(2000);
    return false;
  }
}

String nano_update_response(){
  // Wait until Arduino Nano transfers a data packet via serial communication.
  String data_packet = "";
  while(_CNC.serial_update){
    if(Serial1.available() > 0){
      data_packet = Serial1.readString();
    }
    if(data_packet != ""){
      _CNC.serial_update = false;
    }
    delay(1000);
  }
  // Then, return the obtained data packet.
  return data_packet;
}

void thermal_buffer_collection_via_CNC(String process_type){
  // Initiate the four-step CNC positioning sequence so as to move the thermal camera container head to the predefined points for consecutive data (thermal imaging buffer) collection.
  if(position_start < 4){
    // Transfer CNC commands to Arduino Nano via serial communication.
    Serial1.print(_CNC.pos_command[position_start]);
    delay(2000);
    // Update the given position status to Ongoing.
    _CNC.pos_status[position_start] = 0;
    show_interface("CNC", menu_option);
    delay(500);
    // Wait until Arduino Nano returns the coordinate update confirmation message via the serial communication.
    _CNC.serial_update = true;
    String pos_confirmation = nano_update_response();
    // If Arduino Nano transfers the coordinate confirmation message, update the given position status to Completed.
    // Then, increase the point (position) number.
    if(pos_confirmation == "CNC_OK"){
      _CNC.pos_status[position_start] = 1;
      show_interface("CNC", menu_option);
      delay(5000);
      // After positioning the container head on the given location (point), make an HTTP GET request to the web dashboard in order to make Photon 2 collect and register the associated thermal imaging buffer through the Particle Cloud API.
      // If registered successfully, update the given position status to Saved.
      String request = "assets/Particle_cloud_connection.php?collect_particle_cloud_variable="+String(position_start+1);
      if(make_a_get_request(request)) _CNC.pos_status[position_start] = 2;
      // Update the position (point) number.
      position_start++;
      if(position_start == 4){ show_interface("CNC", menu_option); delay(500); zeroing = true; }
    }
  }
  // After passing all four position points successfully, return the thermal camera container head to the starting point (zeroing).
  if(zeroing){
    Serial1.print(_CNC.pos_command[position_start]);
    delay(4000);
    // Wait until Arduino Nano returns the zeroing confirmation message via the serial communication.
    _CNC.serial_update = true;
    String zero_confirmation = nano_update_response();
    if(zero_confirmation == "CNC_OK"){
      // After the container head returns to the starting point, update all position status indicators (icons) to Image Ready.
      for(int i=0; i<4; i++) _CNC.pos_status[i] = 3;
      position_start++;
      delay(1000);
      zeroing = false;
      // Notify the user of the latest updated status indicators.
      show_interface("CNC", menu_option);
      delay(3000);
    }
  }
  // If Photon 2 registers all thermal imaging buffers successfully and the web dashboard is ready to generate a thermal image from the passed buffers,
  // make an HTTP GET request to the web dashboard to initiate the thermal image conversion process.
  if(_CNC.pos_status[0] == 3 && _CNC.pos_status[1] == 3 && _CNC.pos_status[2] == 3 && _CNC.pos_status[3] == 3){
    // If the web dashboard generates the thermal image successfully, redirect the user to the home screen.
    String request = "assets/Particle_cloud_connection.php?generate_cloud_thermal_image="+process_type;
    if(make_a_get_request(request)){ delay(5000); option_update = false; defective_sound = false; }
  }
}