Update Acquisition.rst

This commit is contained in:
tpollina 2019-12-01 21:00:26 -08:00 committed by GitHub
parent 27645656d9
commit 7430000772
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23

View file

@ -125,383 +125,3 @@ D) Define simple sequence for I2C modules (Valves and pump)
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
################################################################################
start()
while True:
init()
load()
flush()
image()
aeration()
wait()
stop()