Update Acquisition.rst
This commit is contained in:
tpollina
GitHub
parent
b7cbd03be6
commit
c1a1fd0f85
|
|
@ -1,499 +1,22 @@
|
||||||
.. _install:
|
.. _install:
|
||||||
|
|
||||||
============
|
============
|
||||||
Acquisition
|
Installation
|
||||||
============
|
============
|
||||||
|
|
||||||
#!/usr/bin/env python
|
.. currentmodule:: picamera
|
||||||
# coding: utf-8
|
|
||||||
|
|
||||||
################################################################################
|
|
||||||
# A) Import the librairies needed to execute the script
|
|
||||||
################################################################################
|
|
||||||
|
|
||||||
|
.. _raspbian_install:
|
||||||
|
|
||||||
#Activate pinout to control the LEDs and the RELAY
|
Raspbian installation
|
||||||
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
|
|
||||||
################################################################################
|
|
||||||
|
|
||||||
|
|
||||||
|
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()
|
start()
|
||||||
|
|
||||||
while True:
|
while True:
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue