Ненавязчивая автоматизация ректификационной установки

#coding:utf-8
import sys, os, time
import collections
"""Архив с модулями  sens, contr и kbh находятся в приложении к 
   данному топику"""
import sens, contr, kbh

"""Сначала создаем объекты, соответствующие датчикам и контроллерам.
   Параллельно производится проверка их наличия и работоспособности.

   Начнем с датчиков температуры (DS18B20). Идентификаторы датчиков,
   установленных в системе известны. Определяем соответствующие
   переменные"""
hid = 0x180a353 # ID датчика температуры куба
cid = 0x18c5c68 # ID датчика температуры колонны
did = 0x18c4de1 # ID датчика температуры дефлегматора
wid = 0x180c746 # ID датчика температуры выходящей воды
"""Создаем вспомогательный список tids, для удобства коллективной
   работы со всеми датчиками"""
tids = (hid, cid, did, wid)
"""Статический метод Ts() класса DS18B20 возвращает словарь, содержащий
   пары {идентификатор датчика : его температура} для всех датчиков,
   подключенных к шине 1-Wire"""
Ts = sens.DS18B20.Ts()
"""Проверим, все ли датчики, с идентификаторами, перечисленными выше,
   есть в этом словаре (т.е. висят на шине и исправны)"""
flag = False
for id in tids: # Пробегаем по списку нужных нам датчиков
  if Ts.get(id) != None: # Соответствующий ключ (id) есть есть в словаре
    print "0x%012x :% 7.3f°C" % (id, Ts[id]) # Доложим об этом...
  else: # Увы...
    print "Датчик с ID = 0x%012x отсутствует или неисправен" % (id)
    flag = True # Выставляем флаг, что нужного датчика нет на шине
if flag:
  print "Один или более датчиков DS18B20 отсутствуют или неисправны. Завершение работы."
  sys.exit(1)

"""С датчиками температуры разобрались. Теперь займемся датчиком
   RMS (действующее напряжение сети)"""
vs = sens.RMS() # Создаем объект - датчик RMS
if vs != None: # Датчик в наличии и функционирует
  V = vs.V
  if V > 100: print "Действующее напряжение сети %d В" % (V)
  else:
    print "Слишком низкое напряжение сети. Завершение работы."
    sys.exit(2)
else: pass # Ну на нет и суда нет. Можно работать и без датчика RMS
"""Датчик атмосферного давления - полезная вещь. Проверим его наличие
   и работоспособность. Если его нет - не беда. Будем работать без него"""
ps = sens.BMP180() # Создаем объект - датчик атмосферного давления
if ps != None: # Датчик в наличии и функционирует
  print "Атмосферное давление: \t%5.1f мм.рт.ст." % (ps.P)
  print "Температура окружающей среды:\t%5.2f°C" % (ps.T)

"""Создаем объекты-контроллеры исполнительных устройств"""
teh = contr.TEH(vs) # Создадим объект "ТЭН"
if teh == None:
  print "Контроллер ТЭНа отсутствует или неисправен. Завершение работы."
  sys.exit(3)
sd = contr.SD() # Создадим объект "устройство отбора"
"""В принципе можно работать и без клапана отбора. Например, с ручной
   "пережимкой". Если ситуация именно такова, то закомментируйте следующие
   три строчки"""
if sd == None:
  print "Контроллер клапана отбора отсутствует или неисправен. Завершение работы."
  sys.exit(3)

"""Все. С датчиками и исполнительными устройствами мы разобрались.
   Теперь переведем консоль в неблокирующий режим работы. Это нужно
   для того, чтобы можно было бы в главном цикле приложения обрабатывать
   нажатие клавиш клавиатуры. Необходимый для этого сервис организован 
   в виде класса TT, который находится в модуле kbh. При создании объекта
   (экземпляра этого класса) как раз и происходит переход консоли
   в неблокирующий режим. При уничтожении объекта (в деструкторе)
   консоль возвращается к обычному режиму работы.

   Параметр timeout задает время ожидания нажатия клавиши (он может быть
   равен 0). В данном случае мы используем этот параметр для регулирования
   длительности одного такта главного цикла приложения. При timeout = 3000
   длительность такта составляет около 4 сек"""
timeout = 3000 # В мс 
tt = kbh.TT(timeout)

"""Теперь сформируем карту режимов, доступных в данном приложении. Режимы
   пронумерованы от 0 до 6. Карта режимов представляет собой список 
   именованных кортежей (т.е. к элементам кортежа можно обращаться
   по имени). Это очень удобно. Имена элементов кортежа:
   W     - мощность нагрева ТЭНа, Вт (вещественное число)
   stab  - стабилизация мощности нагрева ТЭНа (True/False)
   Q     - скорость отбора, мл/час (вещественное число)
   ststp - режим старт-стопа (True/Flase)"""
#-------------------------------------------------------------------------------
mrec = collections.namedtuple('mrec', 'W stab Q ststp')
modes = [] # Собственно список режимов
modes.append(mrec(0, False, 0, False))        # 0 - Только мониторинг
modes.append(mrec(2000, False, 0, False))     # 1 - Разгон
modes.append(mrec(600, True, 0, False))       # 2 - Холостой ход
modes.append(mrec(600, True, 40, False))      # 3 - Отбора голов
modes.append(mrec(600, True, 400, True))      # 4 - Отбора тела
modes.append(mrec(600, True, 400, False))     # 5 - Отбор хвостов
modes.append(mrec(2000, False, 1000, False))  # 6 - Пропарка колонны

mode = old_mode = 0 # Начинаем работать всегда с нулевого режима

"""Это начало общего отсчета времени (относительное время программы)
   и момент начала текущего режима работы"""
tst = rst = time.time()

"""Теперь откроем файл журнала. Здесь возможны две ситуации. В первом
   варианте мы продолжаем прерванный ранее процесс ректификации. В этом
   случае нам удобно продолжить вести уже существующий файл журнала и
   отсчет времени. Т.е. если файл журнала есть и он не слишком мал,
   то мы так и поступим. Если же файла нет или он мал - то открываем
   новый файл и вдем отсчет локального времени процесса с нуля."""
if os.path.exists("log") and os.path.getsize("log") > 127: 
  log = open("log", "r") # Нужно прочитать последнюю строку
  log.seek(-127, 2) # Встанeм немного недоходя до конца файла
  for line in open("log", "r"): # и считаем последнюю строку
    last_line = line
  prevStopTime = float(last_line.split()[1])
  tst -= prevStopTime*60.0 # Локальное время будет продолжаться с конца
                           # предыдущей сессии
  log.close()
  log = open("log", "a") # А теперь откроем его уже для добавления
else: # В противном случае создаем новый файл журнала а нулевое
  log = open("log", "w") # локальное время уже установлено выше

"""Все. Все подготовительные операции закончены. Входим в главный
   цикл приложения"""
while True:

  """Сначала посмотрим на состояние клавиатуры"""
  if tt.kbhit(): # Какая-то клавиша уже была нажата
    ch = tt.getch() # Смотрим что было нажато....
    if ch == 'q': break # Выходим из цикла - конец работы
    elif ord(ch) >= 48 and ord(ch) <= 57: # Ввели номер режима
      old_mode = mode; mode = int(ch)

  """Теперь довольно громоздкий блок в котором мы измеряем все доступные
     текущие параметры процесса и формируем две строки. Одна (ss) краткая
     и раскрашенная для вывода информации на консоль. Вторая (s) 
     "ненакрашенная" и (обычно) более подробная - для записи в журнал"""

  """Сначала общая длительность процесса на данный момент и длительность
     текущего режима"""
  now = time.time(); dtm = (now - tst)/60.0; dtrm = (now - rst)/60.0
  ss = "% 7.2f % 7.2f\x1b[33m %d\x1b[0m" % (dtm, dtrm, mode)
  """Для журнала добавляем еще и глобальное время"""
  s = time.strftime("%y.%m.%d.%H.%M.%S")
  s += "% 7.2f % 7.2f %d" % (dtm, dtrm, mode)

  """Добавим для выдачи текущие значения температур с датчиков"""
  Ts = sens.DS18B20.Ts() # Сначала их измерим
  for id in tids: # Теперь добавим в строки для выдачи
    if id == cid: # Подкрасим температуру в колонне для консоли
      ss += "\x1b[32m% 6.2f\x1b[0m" % (Ts[id])
    else: ss += "% 6.2f" % (Ts[id])
    s +=  "% 7.3f" % (Ts[id])

  """Измеряем и выводим текущую мощность нагрева"""
  cW = teh.W
  ss += "\x1b[31m %4d\x1b[0m" % (cW); s +=  " %4d" % (cW)

  """Если есть датчик RMS, то в журнал выведем напряжение в сети"""
  if vs != None:
    V = vs.V; s +=  " %3d" % (V)

  """Если есть датчик атмосферного давления - выводим давление"""
  if ps != None:
    P = ps.P; ss += "% 5.1f" % (P); s += "% 5.1f" % (P)

  """Если есть клапан отбора - выводим скорость отбора и общий расход"""
  if sd != None:
    Q = sd.Q; ss += " %4d" % (Q); s += " %4d" % (Q)
    F = sd.F; ss += " %5d" % (F); s += " %5d" % (F)

  log.write(s + "\n"); log.flush() # Пишем данные в журнал
  print ss # и выводим на экран

  """Далее собственно и следует вся ненавязчивая автоматизация :)))

     В данной задаче автоматическое переключение режимов нужно только
     для стадии разгона. Т.е. в режиме разгона (режим 1) после закипания,
     когда температура в 1/3 колонны превысит, скажем, 60°C, нужно 
     перейти в режим 2 (сбросить мощность на "штатный" уровень).
     Ну так так и объясняем малинке."""
  if mode == 1: # Текущий режим - разгон
    if Ts[cid] >= 60: # Куб закипел - пора сбрасывать мощность  
      old__mode = mode; mode = 2

  """Теперь обработаем ситуацию, когда произошла смена режима работы
     установки (автоматически, или по нажатию клавиши). Для обработки
     используем карту режимов"""
  if old_mode != mode:
    """Для режимов без стабилизации мощности (разгон, пропарка колонны и т.п.)
       мощность устанвливается только один раз при смене режима"""
    if not modes[mode].stab and mode != 0: teh.W = modes[mode].W               
    sd.Q = modes[mode].Q # А вот для скорости отбора мы так делаем всегда
    old_mode = mode
    rst = now # Фиксируем момент начала нового режима
  """Для режимов со стабилизацией мощности (это написано в карте режимов),
     мощность обновляем на каждом такте главного цикла приложения
     (естественно, с учетом напряжения сети, если подключен датчик RMS)"""
  if modes[mode].stab:
    teh.W = modes[mode].W