Week 18 : Applications and Implications

Summary

The final project integrates various fabrication techniques and technologies to design an atmospheric pressure plasma reactor for disinfecting endoscopes. This reactor, utilizing atmospheric plasma, aims to neutralize bacteria effectively. The project involves designing the reactor with a dielectric barrier discharge (DBD) and developing a high-voltage generator. Components include 2D and 3D design, additive and subtractive fabrication, electronics design, and system integration. The project addresses the practical application of atmospheric plasma in medical instrument sterilization, emphasizing the creation and testing of both the reactor and its power supply system.

Assignments

Individual Assignments

• Propose a final project masterpiece that integrates the range of units covered, answering:
  • What will it do?
  • Who’s done what beforehand?
  • What will you design?
  • What materials and components will be used?
  • Where will come from?
  • How much will they cost?
  • What parts and systems will be made?
  • What processes will be used?
  • What questions need to be answered?
  • How will it be evaluated?
• Your project should incorporate 2D and 3D design, additive and subtractive fabrication processes, electronics design and production, embedded microcontroller interfacing and programming & system integration and packaging.
• Where possible, you should make rather than buy the parts of your project
• Projects can be separate or joint, but need to show individual mastery of the skills, and be independently operable.

Introduction

Context

My project at the Fab Academy is focused on leveraging its resources to further my doctoral research on atmospheric pressure plasma reactors, specifically for disinfecting endoscopes. These reactors use atmospheric plasma to neutralize bacteria, making them safe. The project involves designing the reactor with a dielectric barrier discharge (DBD) and developing a high-voltage generator to power it. By integrating this advanced technology into the Fablab community, I aim to explore new applications and address practical challenges.

Atmospheric plasma, or cold plasma, is an exciting area of science and technology. Unlike high-temperature plasmas, atmospheric plasma operates at or near room temperature, making it versatile for numerous industrial applications. It comprises ionized gases with reactive species such as ions, electrons, radicals, and UV photons, enabling capabilities like surface cleaning, sterilization, material deposition, and surface modification. Researchers and engineers are utilizing atmospheric plasma to solve problems in healthcare, electronics, agriculture, and more.

Below is an illustration from Carles Corbella & al. showing, in the center, a diagram of plasma activity and its chemical products. On the left are various plasma reactor configurations, and on the right is a real picture of atmospheric plasma.

Project Objective

The goal is to design and develop both the atmospheric plasma reactor and its high-voltage generator.

State of the Art

Atmospheric plasma, often referred to as cold plasma, has emerged as a powerful tool in various fields due to its unique properties and capabilities. The application of atmospheric plasma in surface decontamination, particularly for medical instruments like endoscopes, is a rapidly evolving area of research.

Surface Decontamination using Atmospheric Plasma

A comprehensive review of the literature highlights the efficacy of atmospheric plasma in surface decontamination. It reveals that atmospheric plasma can effectively inactivate a wide range of microorganisms, including bacteria, viruses, and spores, without the need for high temperatures or harmful chemicals . The key mechanisms involve the production of reactive oxygen and nitrogen species (RONS) that disrupt microbial cell membranes and DNA, leading to cell death. This method of decontamination is particularly advantageous in the medical field, where maintaining sterility is crucial.

Plasma Applications in Medicine and Biology

Plasma technology’s potential in medicine and biology extends beyond surface decontamination. It has been employed in wound healing, cancer treatment, and the sterilization of medical devices . The ability of plasma to induce apoptosis in cancer cells while leaving surrounding healthy tissue unharmed is a significant breakthrough. Additionally, plasma’s role in promoting wound healing through the stimulation of cell proliferation and migration underscores its therapeutic potential.

Biomedical Applications of Plasma

Further readings on plasma biomedical applications emphasize its versatility and effectiveness. For instance, atmospheric plasma has been used to modify biomaterial surfaces, enhancing their biocompatibility and functionality . In dentistry, plasma treatments have improved the adhesion of dental materials and facilitated the sterilization of dental tools. The technology also shows promise in the development of new antimicrobial coatings, which can be applied to a variety of medical devices to prevent infections.

References

1. A review of the literature on surface decontamination using atmospheric plasma.
2. A review of plasma applications in medicine and biology
3. More reading on plasma biomedical applications

Technical Specifications

HV Generator

The High-Voltage (HV) Generator is a critical component of the atmospheric plasma reactor system. Its primary function is to convert low-voltage DC power into a high-voltage AC output suitable for generating atmospheric plasma. The design and specifications of the HV Generator include:

Plasma Reactor

The Plasma Reactor is designed to generate atmospheric plasma using the dielectric barrier discharge method. The key components and specifications of the plasma reactor include:

Measurement and Feedback Control

This will not be covered in the final project due to lack of time. Perhaps a future project?

The measurement and feedback control system ensures the stability and efficiency of the plasma reactor by monitoring key parameters and adjusting the system accordingly. Specifications include:

User Interface

The user interface provides control and feedback to the operator, ensuring safe and effective operation of the plasma reactor system. Specifications include:

System Integration

The integration of these components into a cohesive system involves careful design and assembly to ensure compatibility, safety, and functionality. The system’s overall design includes:

Conceptual Design

The conceptual design phase lays the foundation for the entire project by outlining the primary components and their interactions. This stage involves creating a high-level overview of the system, identifying key functionalities, and defining the overall structure of the project. The conceptual design for the atmospheric plasma reactor system includes the following components:

1. High-Voltage (HV) Generator: The HV generator is responsible for producing the high-voltage AC required to generate plasma in the reactor. It involves converting a low-voltage DC input to a high-frequency AC output using power electronics, specifically MOSFETs and a transformer. This subsystem also includes a microcontroller for controlling the operation and ensuring stability.

   

2. Plasma Reactor: The plasma reactor is the core of the system where the plasma is generated. It consists of a dielectric barrier discharge (DBD) setup with high-voltage and ground electrodes separated by a dielectric barrier. A noble gas flows through the reactor, which ionizes under the high-voltage to form plasma. The reactor design includes mechanisms for gas input and output, and structural components to hold the electrodes and dielectric barrier in place.

   

3. Measurement and Feedback Control: This will not be covered in the final project due to lack of time. This subsystem includes various sensors to monitor the high-voltage generator’s output and the plasma reactor’s performance. Key measurements include voltage, current, signal distortion, and the quantity of ionized species produced by the plasma. The feedback control system processes these measurements and adjusts the HV generator settings in real-time to maintain optimal plasma conditions.

4. User Interface: The user interface provides a means for the operator to interact with the system. It includes a display for showing real-time data and system status, control elements such as buttons or a touchscreen for user inputs, and safety indicators to alert the operator of any operational issues or hazards. The interface also allows the user to select different operating modes and power levels.

5. System Integration: The final component involves integrating all subsystems into a cohesive unit. This includes designing an insulated casing to house the HV generator and plasma reactor, ensuring secure and reliable electrical and gas connections, and developing software for the microcontroller and user interface to ensure smooth operation and control.

The conceptual design is visualized using a block diagram that outlines the primary components and their interactions. This high-level overview helps in identifying the key functionalities and defining the overall structure of the project, ensuring that all components work together seamlessly to achieve the desired outcomes.

Each block in the diagram represents a major component of the system, and further details for each component are elaborated in subsequent sections. This conceptual design serves as a blueprint for the detailed design and development phases, guiding the project’s progression from concept to realization.

Embodiment Design

Electronic

The electronic design of the HV Generator focuses on creating a reliable and efficient system capable of transforming low-voltage DC into high-voltage AC suitable for powering the plasma reactor. This section outlines the key components, circuitry, and design considerations involved in achieving this functionality.

Components Selection

The HV Generator circuitry will primarily feature:

• Power MOSFETs: These components will be crucial for switching the low-voltage DC source to generate the high-voltage AC output. I’m going to use IRF3415 MOSFETs because their technical specifications match those of the generator (switch frequency, accepted current, etc.). However, a gate voltage of 5V is required, so I’ll use the MCP1416 gates drivers to increase the control voltage.
• Microcontroller: To control the switching frequency and duty cycle of the MOSFETs, ensuring stable and adjustable output. I’m going to use the RP2040 from Seeed Studio because it’s inexpensive, quite practical in use and design. There’s also the possibility of programming the outputs, which will be necessary when generating the control signal.
• Transformer: Necessary to step up the voltage from low AC to high AC levels required for plasma generation. I’m going to use a high-voltage transformer from a German firm that can be used at high frequencies. It has 2400 turns on the secondary, which will allow for significant voltage decoupling.

Circuit Design

The design of the high-voltage alternator here follows a half-bridge topology with 2 mosfets and two primaries, or a midpoint primary. Each branch takes care of a half-period of the signal. At the output of the transorfamter, a high-voltage sinusoidal signal should be observed. Snubber circuits are also designed to prevent over-voltage at the MOSFET terminals. The circuit diagram is shown below.

As well as the PCB design.

A few design considerations are taken into account:

• The microcontroller will regulate the switching frequency and duty cycle of the MOSFETs to adjust the output voltage of the HV Generator.
• Ensuring minimal power loss and heat dissipation through efficient component selection and design layout.

Manufacturing and Procurement

• Components: MOSFETs, microcontroller, and transformer will be sourced from electronic component suppliers to ensure quality and reliability.
• PCB Fabrication: The printed circuit board (PCB) will be designed and manufactured to accommodate the layout and connections required for the HV Generator circuitry. This was done in week 8. This was done in week 8. This included milling the PCB, as well as soldering the various components onto the PCB.

Below is the result of the PCB manufacturing process.

MicroController Coding

The RP2040 has been programmed in micropython as it was in week 8. The following code uses the RP2040’s PIO function to generate a square-wave signal on two sides of the microcontroller. In addition, a program for communication with the web interface has been added. It allows you to interact with the signal using the interface buttons (explained later). A communication verification system has also been implemented.

from machine import Pin
from rp2 import PIO, StateMachine, asm_pio
import ujson
import sys

sm = None
frequency = 10_000
valid_frequency_range = (100, 50_000)  # Plage de fréquence valide (100 Hz à 200 kHz)

@asm_pio(set_init=(PIO.OUT_LOW, PIO.OUT_LOW))
def square():
    set(pins, 0b0000) [0]   # Deadtime
    set(pins, 0b0001) [20]  # HalfPeriod
    set(pins, 0b0000) [0]   # Deadtime
    set(pins, 0b0010) [20]  # HalfPeriod

def start_signal(frequency):
    """
    Démarre le signal carré avec la fréquence spécifiée.
    """
    global sm
    if sm is not None:
        sm.active(0)
    sm = StateMachine(0, square, freq=40 * frequency, set_base=Pin(26))
    sm.active(1)
    print(ujson.dumps({"status": "Signal démarré", "frequency": frequency}))

def stop_signal():
    """
    Arrête le signal carré.
    """
    global sm
    if sm is not None:
        sm.active(0)
        sm = None
    print(ujson.dumps({"status": "Signal arrêté"}))

def update_frequency(new_frequency):
    """
    Met à jour la fréquence du signal carré.
    """
    global sm, frequency
    frequency = new_frequency
    if sm is not None:
        sm.active(0)
        sm = StateMachine(0, square, freq=40 * frequency, set_base=Pin(26))
        sm.active(1)
    print(ujson.dumps({"status": "Fréquence mise à jour", "frequency": frequency}))

def process_command(command):
    """
    Traite la commande reçue via USB-Serial.
    """
    try:
        data = ujson.loads(command)
        if not isinstance(data, dict) or 'command' not in data:
            raise ValueError("Commande invalide")

        cmd = data['command']
        if cmd == 'START':
            if 'frequency' in data and valid_frequency_range[0] <= data['frequency'] <= valid_frequency_range[1]:
                start_signal(data['frequency'])
            else:
                print(ujson.dumps({"status": "Erreur", "message": "Fréquence invalide"}))
        elif cmd == 'STOP':
            stop_signal()
        elif cmd == 'UPDATE_FREQUENCY':
            if 'frequency' in data and valid_frequency_range[0] <= data['frequency'] <= valid_frequency_range[1]:
                update_frequency(data['frequency'])
            else:
                print(ujson.dumps({"status": "Erreur", "message": "Fréquence invalide"}))
        else:
            print(ujson.dumps({"status": "Erreur", "message": "Commande inconnue"}))

        # Envoi de l'accusé de réception
        print(ujson.dumps({"status": "ACK", "command": cmd}))
    except (ValueError, TypeError) as e:
        print("Erreur de décodage JSON:", e)
        print(ujson.dumps({"status": "Erreur", "message": "JSON invalide"}))

while True:
    command = sys.stdin.readline().strip()
    process_command(command)

Testing

The tests followed several stages:

• Transformerless tests to check MOSFET control signals, gate driver operation, MOSFET operation, and primary output. All this using an oscilloscope to measure and view the signs.
• Next, the transformer was added, and high-voltage measurements could be made using a high-voltage probe (large divider) and displayed via oscilloscope.

User Interface

Development Context

The user interface, accessible here, allows you to control the microcontroller when it’s plugged in via USB. It’s a web page that uses the Web Serial API, as was done in week 15.

The code is made up of an HTML page, which constructs the look and feel of the web page, and a script file, which uses javascript to interact with it. The interface communicates with the microcontroller and checks that communication is complete, verifying the completeness of messages, waiting for acknowledgements, etc.

Coding

HTML code :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Microcontroller Interface</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 20px;
            background-color: #f7f7f7;
        }
        h1 {
            text-align: center;
            color: #333;
        }
        .container {
            max-width: 600px;
            margin: 0 auto;
            padding: 20px;
            background-color: #fff;
            border-radius: 8px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
        }
        label {
            display: block;
            margin-bottom: 5px;
            color: #333;
        }
        input[type="number"], input[type="range"] {
            padding: 8px;
            font-size: 16px;
            width: calc(100% - 16px);
            margin-bottom: 10px;
            border: 1px solid #ccc;
            border-radius: 4px;
            box-sizing: border-box;
        }
        button {
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
            background-color: #007bff;
            color: #fff;
            border: none;
            border-radius: 4px;
            margin-right: 10px;
        }
        button:hover:enabled {
            background-color: #0056b3;
        }
        button:disabled {
            background-color: #ccc;
            cursor: not-allowed;
        }
        pre {
            margin-top: 20px;
            background-color: #f5f5f5;
            padding: 10px;
            border-radius: 4px;
            overflow-x: auto;
        }
        #output {
            max-height: 200px;
            overflow-y: auto;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Microcontroller Interface</h1>
        <button id="connectButton">Connecter</button>
        <button id="disconnectButton" disabled>Déconnecter</button>
        <br><br>
        <label for="frequency">Fréquence (Hz):</label>
        <input type="range" id="frequencyRange" name="frequencyRange" min="100" max="50000" step="100" value="10000">
        <input type="number" id="frequency" name="frequency" value="10000" min="100" max="50000" step="100">
        <br><br>
        <div>
            <button id="startButton" disabled>Démarrer</button>
            <button id="stopButton" disabled>Arrêter</button>
            <button id="updateButton" disabled>Mettre à jour la fréquence</button>
        </div>

        <pre id="output"></pre>
        <pre id="status"></pre>
    </div>

    <script src="./main.js"></script>
</body>
</html>

JavaScript code:

let port;
let isReading = false;
let writer;
let reader;
let partialMessage = ''; // Stocker les messages partiels
let isSignalRunning = false; // Indiquer si le signal est en cours d'exécution

const outputElement = document.getElementById('output');
const statusElement = document.getElementById('status');
const frequencyInput = document.getElementById('frequency');
const frequencyRange = document.getElementById('frequencyRange');

document.getElementById('connectButton').addEventListener('click', connect);
document.getElementById('disconnectButton').addEventListener('click', disconnect);
document.getElementById('startButton').addEventListener('click', start);
document.getElementById('stopButton').addEventListener('click', stop);
document.getElementById('updateButton').addEventListener('click', updateFrequency);

// Synchroniser le champ de saisie numérique avec le curseur coulissant
frequencyRange.addEventListener('input', () => {
    frequencyInput.value = frequencyRange.value;
});
frequencyInput.addEventListener('input', () => {
    frequencyRange.value = frequencyInput.value;
});

async function connect() {
    if (!("serial" in navigator)) {
        alert("Web Serial API non supportée.");
        return;
    }

    try {
        port = await navigator.serial.requestPort();
        await port.open({ baudRate: 115200 });

        reader = port.readable.getReader();
        writer = port.writable.getWriter();

        readLoop();
        
        updateUIConnected(true);
        statusElement.textContent = "Connecté au port série.";
    } catch (err) {
        statusElement.textContent = "Erreur de connexion au port série: " + err;
    }
}

async function disconnect() {
    if (port) {
        try {
            // Arrêter le signal s'il est en cours d'exécution
            if (isSignalRunning) {
                await stop();
            }

            // Relâcher les verrous avant de fermer le port
            if (reader) {
                await reader.cancel();
                reader.releaseLock();
            }
            if (writer) {
                await writer.close();
                writer.releaseLock();
            }

            await port.close();
            port = null;

            updateUIDisconnected();
            statusElement.textContent = "Déconnecté du port série.";
        } catch (err) {
            console.error('Erreur lors de la déconnexion:', err);
            statusElement.textContent = "Erreur lors de la déconnexion: " + err;
        }
    } else {
        statusElement.textContent = "Aucun port série connecté.";
    }
}

async function start() {
    const frequency = parseInt(frequencyInput.value);
    if (isValidFrequency(frequency)) {
        isSignalRunning = true;
        updateSignalButtons();
        await sendCommand({ command: "START", frequency: frequency });
        statusElement.textContent = "Commande START envoyée.";
    } else {
        alert("Fréquence invalide. Veuillez entrer une fréquence entre 100 et 200000 Hz.");
    }
}

async function stop() {
    isSignalRunning = false;
    updateSignalButtons();
    await sendCommand({ command: "STOP" });
    statusElement.textContent = "Commande STOP envoyée.";
}

async function updateFrequency() {
    const frequency = parseInt(frequencyInput.value);
    if (isValidFrequency(frequency)) {
        await sendCommand({ command: "UPDATE_FREQUENCY", frequency: frequency });
        statusElement.textContent = "Commande UPDATE_FREQUENCY envoyée.";
    } else {
        alert("Fréquence invalide. Veuillez entrer une fréquence entre 100 et 200000 Hz.");
    }
}

function isValidFrequency(frequency) {
    return frequency >= 100 && frequency <= 50000;
}

async function sendCommand(command) {
    if (port) {
        try {
            const message = JSON.stringify(command) + '\n';
            await writer.write(new TextEncoder().encode(message));

            // Attendre l'accusé de réception
            const ack = await waitForAck(command.command, 5000);
            if (ack) {
                statusElement.textContent = `Accusé de réception pour ${command.command} reçu.`;
            } else {
                statusElement.textContent = `Aucun accusé de réception pour ${command.command}.`;
                
                // Réactiver les boutons correspondants si l'accusé de réception n'est pas reçu
                if (command.command === "START") {
                    isSignalRunning = false;
                    updateSignalButtons();
                } else if (command.command === "STOP") {
                    isSignalRunning = true;
                    updateSignalButtons();
                }
            }
        } catch (err) {
            console.error('Erreur d\'envoi de commande:', err);
            statusElement.textContent = "Erreur d'envoi de commande: " + err;
        }
    } else {
        statusElement.textContent = "Non connecté au port série.";
    }
}

async function waitForAck(command, timeout) {
    return new Promise((resolve) => {
        const startTime = Date.now();
        const interval = setInterval(() => {
            if (Date.now() - startTime > timeout) {
                clearInterval(interval);
                resolve(false);
            }

            const ackMessage = outputElement.textContent.split('\n').find(line => {
                try {
                    const msg = JSON.parse(line);
                    return msg.status === "ACK" && msg.command === command;
                } catch (e) {
                    return false;
                }
            });

            if (ackMessage) {
                clearInterval(interval);
                resolve(true);
            }
        }, 100);
    });
}

async function readLoop() {
    isReading = true;
    while (isReading) {
        try {
            const { value, done } = await reader.read();
            if (done) {
                reader.releaseLock();
                break;
            }
            const message = new TextDecoder().decode(value);
            processMessage(message);
        } catch (err) {
            console.error('Erreur de lecture:', err);
            break;
        }
    }
    isReading = false;
}

function processMessage(message) {
    partialMessage += message; // Ajouter le fragment au message partiel

    let endOfMessageIndex;
    while ((endOfMessageIndex = partialMessage.indexOf('\n')) >= 0) {
        const completeMessage = partialMessage.slice(0, endOfMessageIndex);
        partialMessage = partialMessage.slice(endOfMessageIndex + 1);

        try {
            const jsonMessage = JSON.parse(completeMessage);
            outputElement.textContent += JSON.stringify(jsonMessage, null, 2) + '\n';
        } catch (e) {
            console.error('Erreur de lecture JSON:', e);
            outputElement.textContent += "Erreur de lecture JSON: " + completeMessage + '\n';
        }
    }
}

function updateUIConnected(connected) {
    document.getElementById('disconnectButton').disabled = !connected;
    document.getElementById('connectButton').disabled = connected;
    document.getElementById('startButton').disabled = !connected;
    document.getElementById('updateButton').disabled = !connected;
    if (!isSignalRunning) {
        document.getElementById('stopButton').disabled = true;
    }
}

function updateUIDisconnected() {
    document.getElementById('connectButton').disabled = false;
    document.getElementById('disconnectButton').disabled = true;
    document.getElementById('startButton').disabled = true;
    document.getElementById('stopButton').disabled = true;
    document.getElementById('updateButton').disabled = true;
}

function updateSignalButtons() {
    document.getElementById('startButton').disabled = isSignalRunning;
    document.getElementById('stopButton').disabled = !isSignalRunning;
}

navigator.serial.addEventListener('disconnect', (event) => {
    if (port && event.target === port) {
        updateUIDisconnected();
        statusElement.textContent = "Port série déconnecté.";
    }
});

Testing User Interface

Interface tests were carried out with the RP2040 microcontroller as described above. I tested the various functions of the interface by looking at the responses it generated in the console. I also used an acknowledgement system to ensure that communication was taking place normally.

Gas system

The gas system feeds the gas into the plasma reactor. In this case, the plasma is generated with a gas flow, which enables the gas to be renewed.

There is therefore an inlet and an outlet for the gas. And the gas system consists of a simple tube. Connections are used to uncouple the plasma reactor from the gas canister.

To control the flow, a valve was installed upstream.

Components Selection

The system components are:

• The flow control valve.
• PFA tubes
• Steel tubes, used for high-voltage connections.
• Tube fittings (unknow reference).
• Rigid tube fittings, used for the glass tube dielectric (unknow reference).

Gas Circuit Design

The design of the gas circuit is very simple, as shown below.

Manufacturing and Procurement

As far as procuring the components is concerned, I used the stocks in the lab where I work. It made the design easier to already have the material, because it limited what could be done. What guided my design was mainly the availability of components in the lab.

Nevertheless, I had to cut the tubes to the desired lengths. Especially the steel ones. To do this, I used the same model of tube cutter that can be found here.

Testing

When the gas system has been installed. I was able to test it directly by inserting the high-voltage electrode inside the glass tube, and surrounding the same tube with the ground electrode, which is a steel mesh. The two electrodes are shown below.

The test was carried out with a commercially available generator different from the one I made, to make sure that if there was a problem, it didn’t come from my generator.

System Integration

System integration development was completed in week 17. The aim is to assemble the various systems together in a clean and accessible way.

Detailed Design

3D Design

High Voltage Generator

The high-voltage generator was modeled in 3D during integration. Here we present the various components that make up the generator.

HV Transformer

Fan

PCB

Box

Plexi Lid

MDF support

Then two views of the assembly, with and without the box and lid.

Assembly - Inside

Assembly - Outside

Plasma Reactor

The plasma reactor was also modeled in 3D during integration.

MDF Support

Plexi Lid

Protective Plexi Windows

Box

Gas System & DBD

As well as its assembly.

Assembly

Bill of materials (BOM)

Below is a detailed Bill of Materials for the atmospheric pressure plasma reactor project:

1. Structural Components

2. Dielectric Barrier Discharge (DBD) Components

3. High-Voltage Generator Components

4. Gas System Components

5. Additional Components

Total Estimated Cost: 131.35 €

This BOM includes the necessary components and materials to construct the atmospheric pressure plasma reactor & its high voltage generator. Prices are from the sellers or an estimation in case of no identified seller.

Results

HV Generator

The final result of the generator is shown below. It can be controlled via the user interface accessible here.

High Voltage Generator - Inside

High Voltage Generator - Outside

Plasma Reactor

The final result of the plasma reactor is shown below.

Plasma Reactor - Outside

Final Setup

The final setup consists of a plasma reactor connected to a high-voltage generator and a gas supply. A computer with an interface is needed to control the high-voltage generator. A view of the setup is shown below.

Final Setup - From left to right : Low DC Power Supply, Plasma Reactor, HV Generator, Computer

Workflow

To switch on the plasma, you must :

• Make all connections (gas and voltage).
• Turn on the gas flow.
• On the UI, establish the connection, and switch on the signal after choosing its frequency.
• Activate the switch on the HV generator.
• Increase the DC voltage as you go in.

To switch off the plasma, you can either :

• Stop signal generation on the UI.
• Switch off DC power supply.
• Turn off the switch on the HV generator.

Here are a few images of the setup in operation.

Conclusion

In conclusion, the project successfully demonstrates the integration of multiple advanced technologies to develop an atmospheric plasma reactor for medical use. By combining 2D and 3D design, various fabrication processes, and electronics, the project not only highlights the practical applications of atmospheric plasma but also showcases the ability to create functional, innovative solutions within the Fab Lab environment. The results affirm the potential of atmospheric plasma technology in enhancing sterilization processes, contributing to advancements in medical safety and efficiency. Future work could expand on the feedback control systems and further optimize the reactor design for broader applications.