curious.bio/planktoscope
curious.bio/planktoscope
8
0
Fork 0
Code Issues 10 Pull requests Packages Projects 7 Releases Wiki Activity

Update Acquisition.rst

Browse source
This commit is contained in:
tpollina 2019-12-01 20:57:16 -08:00 committed by GitHub
parent b7cbd03be6
commit c1a1fd0f85
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 10 additions and 487 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

497
docs/Acquisition.rst
View file

@ -1,499 +1,22 @@
.. _install:
============
Acquisition
Installation
============
#!/usr/bin/env python
# coding: utf-8
.. currentmodule:: picamera
################################################################################
# A) Import the librairies needed to execute the script
################################################################################
.. _raspbian_install:
#Activate pinout to control the LEDs and the RELAY
from gpiozero import LED
#Allow to access the I2C BUS from the Raspberry Pi
import smbus2 as smbus
#Time librairy in order to sleep when need
from time import sleep
#Picamera library to take images
from picamera import PiCamera
#Enable calculation of remaining duration and datetime
from datetime import datetime, timedelta
#Enable creation of new folders
import os
################################################################################
# B) Define the used pinout
################################################################################
#Affiliate pin to var for the LEDs
GREEN = LED(16)
RED = LED(12)
BLUE = LED(26)
#Affiliate pin to var for the RELAY
RELAY = LED(14)
################################################################################
# C) Configuration file
################################################################################
camera = PiCamera()
camera.resolution = (2592, 1944)
camera.iso = 60
camera.exposure_mode = 'off'
camera.shutter_speed = 100
camera.awb_mode = 'off'
camera.awb_gains = (2,1)
nb_frame=300
duration_loading=120 #(sec)
duration_flushing=20 #(sec)
duration_aeration=30 #(sec)
################################################################################
# D) Define simple sequence for I2C modules (Valves and pump)
################################################################################
def pump(state, verbose=True):
sleep(0.2)
if state is 'forward':
# Stop pumping
bus.write_byte(0x30, 1)
sleep(1)
feedback=bus.read_byte(0x30)
if feedback == 1:
if verbose is True:
print("Pumping : Forward")
if state is 'backward':
# Stop pumping
bus.write_byte(0x30, 2)
sleep(1)
feedback=bus.read_byte(0x30)
if feedback == 2:
if verbose is True:
print("Pumping : Backward")
if state is 'stop':
# Stop pumping
bus.write_byte(0x30, 0)
sleep(1)
feedback=bus.read_byte(0x30)
if feedback == 0:
if verbose is True:
print("Pumping : Stop")
if state is 'slow':
# Start pumping
bus.write_byte(0x30, 3)
sleep(1)
feedback=bus.read_byte(0x30)
if feedback == 3:
if verbose is True:
print("Pumping : Slow")
if state is 'medium':
# Start pumping
bus.write_byte(0x30, 5)
sleep(1)
feedback=bus.read_byte(0x30)
if feedback == 5:
if verbose is True:
print("Pumping : Medium")
if state is 'fast':
# Start pumping
bus.write_byte(0x30, 9)
sleep(1)
feedback=bus.read_byte(0x30)
if feedback == 9:
if verbose is True:
print("Pumping : Fast")
################################################################################
def valve(state, verbose=True):
sleep(0.2)
if state is 'open_all':
bus.write_byte(0x20, 1)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 1:
if verbose:
print("Valve : All open")
if state is 'close_all':
bus.write_byte(0x20, 0)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 0:
if verbose:
print("Valve : All closed")
if state is 'open_in_sample':
bus.write_byte(0x20, 2)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 2:
if verbose:
print("Valve : In sample open")
if state is 'close_in_sample':
bus.write_byte(0x20, 3)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 3:
if verbose:
print("Valve : In sample closed")
if state is 'open_in_air':
bus.write_byte(0x20, 4)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 4:
if verbose:
print("Valve : In air open")
if state is 'close_in_air':
bus.write_byte(0x20, 5)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 5:
if verbose:
print("Valve : In air closed")
if state is 'open_in_bleach':
bus.write_byte(0x20, 6)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 6:
if verbose:
print("Valve : In bleach open")
if state is 'close_in_bleach':
bus.write_byte(0x20, 7)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 7:
if verbose:
print("Valve : In bleach closed")
if state is 'open_out_bleach':
bus.write_byte(0x20, 8)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 8:
if verbose:
print("Valve : Out bleach open")
if state is 'close_out_bleach':
bus.write_byte(0x20, 9)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 9:
if verbose:
print("Valve : Out bleach closed")
if state is 'open_out_sample':
bus.write_byte(0x20, 10)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 10:
if verbose:
print("Valve : Out sample open")
if state is 'close_out_sample':
bus.write_byte(0x20, 11)
sleep(1)
feedback=bus.read_byte(0x20)
if feedback == 11:
if verbose:
print("Valve : Out sample closed")
################################################################################
# E) Define simple functions making the whole sequence
################################################################################
#First function to run in order to turn on the blue LED as well as the relay to make the I2C operationnal
def start():
print("###############")
print("STARTING")
print("###############")
#Inform on the statut of the operation
print("Starting : engaged")
#turn the blue LED ON (even if it's written off here)
BLUE.off()
print("Led : Blue on")
#turn the circuit ON (even if it's written off here)
RELAY.off()
print("Relay : Activated")
for i in range(3):
GREEN.off()
print("Led : Green on")
RED.off()
print("Led : Red on")
sleep(0.1)
GREEN.on()
print("Led : Green off")
RED.on()
print("Led : Red off")
sleep(0.1)
directory="/pi/home/Desktop/PlanktonScope_acquisition/"
#create a directory if the directory doesn't exist yet
if not os.path.exists(directory):
os.makedirs(directory)
GREEN.off()
#Inform on the statut of the operation
print("Starting : done")
################################################################################
#This function will prepare the pump and the valves to realize the loading operation
def init():
print("###############")
print("INITIALIZING")
print("###############")
#Inform on the statut of the operation
print("Initializing : engaged")
pump('forward', True)
pump('stop', True)
valve('open_in_sample', True)
valve('open_out_sample', True)
valve('close_in_air', True)
valve('close_in_bleach', True)
valve('close_out_bleach', True)
#Inform on the statut of the operation
print("Initializing : done")
################################################################################
#The load will simply load a sample by pumping fast during a long period
def load():
print("###############")
print("LOADING")
print("###############")
#Inform on the statut of the operation
print("Loading : engaged")
pump('fast', True)
#wait to complete the loading process and print info on the terminal
for i in range(duration_loading):
print("Loading : "+str(i)+"/"+str(duration_loading))
sleep(1)
#Inform on the statut of the operation
print("Loading : done")
################################################################################
#flush will create some valving sequence to remove potential air trapped in the tubes
def flush():
print("###############")
print("FLUSHING")
print("###############")
#Inform on the statut of the operation
print("Flushing : engaged")
valve('close_in_sample', True)
valve('open_in_sample', True)
valve('close_in_sample', True)
valve('open_in_sample', True)
pump('slow', True)
#wait to complete the flushing process and print info on the terminal
for i in range(duration_flushing):
print("Flushing : "+str(i)+"/"+str(duration_flushing))
sleep(1)
#Inform on the statut of the operation
print("Flushing : done")
################################################################################
#image is very a basci way to take images
def image():
print("###############")
print("IMAGING")
print("###############")
#Inform on the statut of the operation
print("Imaging : engaged")
#start the preview only during the acquisition
camera.start_preview(fullscreen=False, window = (160, 0, 640, 480))
#allow the camera to warm up
sleep(2)
for frame in range(nb_frame):
#turn the green LED ON (even if it's written off here)
GREEN.off()
sleep(0.5)
#get the actual date
date = datetime.now().strftime("%m_%d_%Y")
directory="/pi/home/Desktop/PlanktonScope_acquisition/"+str(date)
#create a directory if the directory doesn't exist yet
if not os.path.exists(directory):
os.makedirs(directory)
#get the time now
time = datetime.now().strftime("%H_%M_%S_%f")
#create a filename from the date and the time
filename="/pi/home/Desktop/PlanktonScope_acquisition/"+str(date)+"/"+str(time)+".jpg"
#capture an image with the specified filename
camera.capture(filename)
#wait to complete the imaging process and print info on the terminal
print("Imaging : "+str(frame)+"/"+str(nb_frame))
#turn the green LED OFF (even if it's written on here)
GREEN.on()
sleep(0.5)
#stop the preview during the rest of the sequence
camera.stop_preview()
GREEN.off()
pump('stop', True)
#Inform on the statut of the operation
print("Imaging : done")
################################################################################
#aeration will remove the liquid from the tube and replace it by air
def aeration():
print("###############")
print("AERATION")
print("###############")
#Inform on the statut of the operation
print("Aeration : engaged")
#remove liquid from tubes
pump('stop', True)
valve('close_all', True)
valve('open_in_air', True)
valve('open_out_sample', True)
pump('medium', True)
#wait to complete the aeration process and print info on the terminal
for i in range(duration_aeration):
print("Aerating : "+str(i)+"/"+str(duration_aeration))
sleep(1)
pump('stop', True)
#Inform on the statut of the operation
print("Aeration : done")
################################################################################
#wait will make the pi sleep until the next hour
def wait():
print("###############")
print("WAITING")
print("###############")
#Inform on the statut of the operation
print("Waiting : engaged")
# Calculate the delay to the start of the next hour
next_hour = (datetime.now() + timedelta(hour=1)).replace(
minute=0, second=0, microsecond=0)
delay = (next_hour - datetime.now()).seconds
#wait to complete the waiting process and print info on the terminal
for i in range(delay):
print("Waiting : "+str(i)+"/"+str(delay))
sleep(1)
#Inform on the statut of the operation
print("Waiting : done")
################################################################################
#stop will turn off the green LED and turn on the red one
def stop():
GREEN.on()
print("Led : Green off")
RED.off()
print("Led : Red on")
#Inform on the statut of the operation
print("The sequence is done.")
################################################################################
# F) Execute the sequence
################################################################################
Raspbian installation
=====================
If you are using the `Raspbian`_ distro, it is best to install picamera using
the system's package manager: apt. This will ensure that picamera is easy to
keep up to date, and easy to remove should you wish to do so. It will also make
picamera available for all users on the system. To install picamera using apt
simply::
start()
while True: