The chemios from chemios

👨🏾‍🔬 Why Chemios?
🛠️ Installation
👍 Examples
📋 Documentation
⚙️ Compatible Equipment
🎁 Contributing

👨🏾‍🔬 Why chemios?

The Problem

Laboratories have a lot of equipment—pumps, spectrometers, incubators, etc. One laboratory's equipment is usually worth millions of dollars.

Despite their price tag, these devices rarely have simple software interfaces. So, monitoring them remotely or integrating them into automated experiments is difficult.

We looked at the existing solutions, and we were not satisfied. Tetrascience is a paid monitoring platform that is unaffordable for most labs. Labview has been used to automate lab equipment (see Epps et al., Reizman et al., or Dragone et al.). However, LabView licenses cost $5000 annually. ThermoFisher Cloud is the most promising solution, but it only works with a limited number of Thermofisher products.

The Solution

The Chemios Framework is a simple, open-source (i.e. FREE) software package for laboratory automation and monitoring. It is easy-to-use and extensible. It currently works with pumps, spectrometers and temperature controllers. And, the list of equipment will continue to grow (see Compatible Equipment) through an open source community.

The framework is written in python (the unoffical language of science) and actively maintained. We are looking for which equipment to automate next; please vote for what equipment you'd like to see with what you would like to see!

🛠️ Installation

Follow the steps below to design and run your first experiment in minutes.

Install python (version 3 or above) if you haven't already. If you are using Windows, it is recommended to install python in the cygwin terminal.
Download this repository (via the green button above) or clone it:
```
$ git clone https://github.com/Chemios/chemios.git
```
Enter into the root of the repository directory and run:
```
pip install -e .;pip install -r requirements.txt
```

👍 Examples

Here is a how you'd use chemios to run a pump in an automated fashion.

from chemios.pumps import Chemyx
from time import sleep
import serial

#Set up serial port for communciation with pump over USB
ser = serial.Serial(port='ttyUSB0', timeout=1, baudrate=9600)

#Connect to a Harvard Apparatus PhD Ultra
C = Chemyx(model='Phd-Ultra', ser=ser, 
           syringe_manufacturer='Hamilton', syringe_volume=10)

#Set the flowrate to infuse at 100 microliters per minute
rate = {'value': 100, 'units': 'UM'}                   
C.set_rate(rate=rate, direction = 'INF')

#Run the pump for 5 seconds
C.run()
sleep(5)

#Stop the pump
C.stop()

📋 Documentation

You can find documentation for the chemios framework here. More examples will be added soon.

⚙️ Compatible Equipment

Chemios currently works with the following types of devices:
- Syringe Pumps: Harvard Apparatus, Chemyx, and New-Era
- Spectrometers: Ocean Optics
- Temperature Controllers: Omega CN 9300 Series
Please vote for what equipment you'd like to see with what you would like to see!
Roadmap:
- Finish unit testing syringe pumps (May 2018)
- Add create-device script for easily creating a device (May 2018)
- Publish package on PyPI (June 2018)
- Create experiments module for automating (June 2018)
- More to come based on your input.

🎁 Contributing

We ❤️ contributors! The Chemios Framework came out of a senior design project at NC State and is now maintained by Kobi Felton @marcosfelt.

We are looking in particular for people to extend the framework to work with more types of laboratory equipment. Feel free to email Kobi if you're interested. If you already have some changes, please submit a pull request.

Instrument/Instrument-type Templating Engine

Problem: Currently, creating a new instrument is time-consuming and error prone; you might forget to add the new instrument to the subpackage level in init.py or not use a consistent interface across all instruments of a certain type.

Solution: As a developer, I would like a script that creates the proper folders, files, etc for a new instrument type (e.g., pumps) or instruments (e.g., Harvard Apparatus). My thought is that the folder structure should be something like this:

chemios/
   __init__.py
   pumps/ 
       __init__.py #Import classes from individual pumps to subpackage level
       _base_pump.py  #Contains abstract base class that all pumps must inherit
       {{cookiecutter.pumpname}}.py  #Contains template for all pumps.
       Chemyx.py 
       HarvardApparatus.py
       NewEra.py 
    temperature_controllers/
       ....same thing

For a new instrument type, the script would create a directory called the name of the instrument type. Inside the directory, the script would create a base{instrumenttype}.py and a template file. The _base file would contain the abstract base class (ABC)that determines which methods each instance of that instrument must implement. For example, the abstract base class for a pump will probably look something like:

from collections import ABC

class pumpABC(ABC):
     @abstractmethod
    def set_rate(rate, direction):
         pass

    @abstractmethod
    def run():
         pass

Each pump will inherit this ABC and be required to implement the set_rate and run methods.

The template file, which is named using Jinja syntax, could be copied and the name of the pump substittuted by cookiecutter. This file will already have the abstract base classes ready to implement, making the setup process less error-prone.

chemios / chemios Goto Github PK

chemios's Introduction

Contents

👨🏾‍🔬 Why chemios?

The Problem

The Solution

🛠️ Installation

👍 Examples

📋 Documentation

⚙️ Compatible Equipment

🎁 Contributing

chemios's People

Contributors

Stargazers

Watchers

Forkers

chemios's Issues

Recommend Projects

Recommend Topics

Recommend Org