.. _install:

============
Installation
============

.. currentmodule:: picamera


.. _raspbian_install:

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::

A) Import the librairies needed to execute the script
=======================================================

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::

  from gpiozero import LED
  import smbus2 as smbus
  from time import sleep
  from picamera import PiCamera
  from datetime import datetime, timedelta
  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
  ################################################################################


  start()

  while True: 
      init()
      load()
      flush()
      image()
      aeration()
      wait()

  stop()