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

#include <avr/io.h>
#include <util/twi.h>
#include <avr/interrupt.h>

#define F_CPU 16000000UL
#define ADDR 0x13      // Адрес устройства на шине I2C
#define PULSE_WIDTH 78 // Длительность управляющего импульса - около 5 мс
                         
volatile uint8_t pdm = 0;   // Требуемый уровень PDM-модуляции в %
volatile int16_t err = 0;   // Ошибка дискретизации
volatile int8_t pp = 1;     // Относительный знак предстоящего полупериода
                            // 1 - положительный, 0 - отрицательный
volatile int16_t ps = 0;    // Отклонение постоянной составляющей от 0
volatile uint8_t pFlag = 0; // Флаг: 1 - пропускаем полупериод к нагрузке, т.е.
                            // подаем управляющий импульс на моську, 0 - нет
volatile int16_t lev;       // Текущий уровень (pdm + err)
//------------------------------------------------------------------------------
ISR(TWI_vect) { // Обработчик событий модуля TWI
  switch(TW_STATUS) {    // Статус - в 5 старших битах регистра TWSR
    case TW_SR_DATA_ACK: // Данные приняты, ACK отправлен - 0x80
      pdm = TWDR;
      if(pdm > 100) pdm = 100;
      break;
    case TW_ST_SLA_ACK:  // Запрос SLA+R, ACK отправлен - 0xA8
      break;
    case TW_BUS_ERROR:   // Неверные условия "старт" или "стоп" - 0x00
      TWCR = _BV(TWIE) | _BV(TWINT) | _BV(TWEA) | _BV(TWEN); // "Сброс" TWI
      break;
  }
  TWCR |= _BV(TWINT);   // Флаг TWINT здесь НЕ очищается автоматически! Очистим.
} 
//------------------------------------------------------------------------------
ISR(INT0_vect) { // Внешнее прерывание INT0 (Zero от детектора нуля)
  lev = pdm + err; // Текущий уровень выходного сигнала (мощности)
  pFlag = (lev >= 50)? 1 : 0; // Предварительное решение
  if(ps*pFlag*pp > 0)         // Однако, если подадим импульс, то постоянная
    pFlag = 0;                // составляющая возрастет. Значит - не будем
                              // подавать - отложим да следующего полупериода
  if(pFlag) { // Положительное решение принято - дадим этот полупериод нагрузке
    PORTD |= _BV(PD0);        // Подаем управляющий импульс
    err = lev - 100;          // Оцениваем ошибку (сколько "переложили")
  } else err = lev;           // Если не дали - сколько "недоложили"
  GTCCR = _BV(PSRASY);        // Сброс предделителя таймера 2
  TCNT2 = 0;                  // Обнуляем счетчик таймера 2
  ps += pp*pFlag;             // Считаем текущую постоянную составляющую
  pp = -pp;                   // Следующий полупериод будет другого знака
}
//------------------------------------------------------------------------------
ISR(TIMER2_COMPA_vect) { // Обработчик по совпадению с регистром A
  PORTD &= ~_BV(PD0); // Завершаем управляющий импульс
}
//------------------------------------------------------------------------------
int main(void) {
  DDRD = _BV(PD0); // Пин PD0 - на вывод (управление оптосимистором)
  // Инициализация TWI-модуля --------------------------------------------------
  TWAR = ADDR << 1;   // Адрес устройства - в старших 7 битах
  TWCR = _BV(TWIE);   // Разрешаем прерывания от TWI
  TWCR |= _BV(TWEA);  // Разрешаем подачу импульса ACK
  TWCR |= _BV(TWINT); // Очистим флаг TWINT (очищается при установке в 1)
  TWCR |= _BV(TWEN);  // Разрешаем работу TWI и активирует TWI-интерфейс
  // Инициализация внешнего прерывания INT0
  EICRA = _BV(ISC01) | _BV(ISC00); // Прерывания по фронту на пине PD2/INT0
  EIMSK = _BV(INT0); // Разрешаем внешние прерывания на пине PD2/INT0
  // Инициализация таймера 2 для формирования управляющего импульса для
  // MOC3083 длительностью приблизительно 5 мс
  // Счетчик работает в обычном режиме (Normal mode)
  TCCR2B |= _BV(CS22) | _BV(CS21) | _BV(CS20); // Предделитель на 1024
  OCR2A = PULSE_WIDTH; // Длительность управляющего импульса
  TIMSK2 = _BV(OCIE2A); // Разрешаем прерывания по совпадению
  
  sei(); // Разрешаем глобальные прерывания
  while(1) { // Бесконечный цикл
  }
  return 0;
}

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
import kbh # В этом модуле - функция kbhit() для работы с клавиатурой
           # в неблокирующем режиме
#-------------------------------------------------------------------------------
# Тестирование прошивки контроллера ТЭНа
#-------------------------------------------------------------------------------
# Управление контроллером ТЭНа:
# '+' - увелить уровень pdm
# '-' - уменьшить уровень pdm
# 'm' - pdm - на 100%
# '0' - pdm - в 0
# Управление контроллером контактора:
# '1' - включить контактор
# '2' - выключить контактор
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина i2c"
addrC = 0x12 # Адрес контроллера контактора
addrT = 0x13 # Адрес контроллера ТЭНа на шине i2c
tt = kbh.TT(500) # Создаем объект - терминал, работающий в неблокирующем режиме
                 # timeout = 500 ms
pdm = 0 # Уровень pdm (pulse density modulation, ака Брезенхем)
opdm = 0
while True:
  if tt.kbhit(): # Была нажата какая-то клавиша
    ch = tt.getch() # Получаем введенный символ
    if ch == 'q': # Выход их программы 
      bus.write_byte(addrT, 0) # Выключить ТЭН
      bus.write_byte(addrC, 0) # Выключить контактор
      break
    elif ch == '+' or ch == '=': # Увеличим уровень pdm
      pdm += 1
      if pdm > 100: pdm = 100
    elif ch == '_' or ch == '-': # Уменьшим уровень pdm
      pdm -= 1
      if pdm < 0: pdm = 0
    elif ch == '0': pdm = 0      # Минимальный уровень pdm - 0%
    elif ch == 'm': pdm = 100    # Максимальный уровень pdm - 100%
    elif ch == '1': bus.write_byte(addrC, 1) # Включим контактор
    elif ch == '2': bus.write_byte(addrC, 0) # Выключим контактор
  if opdm <> pdm: # Уровень pdm был изменен - пошлем его контроллеру и покажем его на терминале
    bus.write_byte(addrT, pdm)   # Шлем уровень pdm контроллеру ТЭНа
    print pdm; opdm = pdm

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
from Tkinter import * # Инструментарий для GUI
#-------------------------------------------------------------------------------
# Тестирование firmware контроллера ТЭНа
#-------------------------------------------------------------------------------
addrC = 0x12 # Адрес контроллера контактора
addrT = 0x13 # Адрес контроллера ТЭНа
#-------------------------------------------------------------------------------
def fC(): # Вызывается при изменении состояния чекбокса
  global vC
  bus.write_byte(addrC, vC.get());
#-------------------------------------------------------------------------------
def fT(): # Вызывается при изменении состояния спинбокса
  global sbT, pdm
  pdm = int(sbT.get())
  bus.write_byte(addrT, pdm);
#-------------------------------------------------------------------------------
def wclose(): # Перед закрытием главного окна приложения выключим ТЭН
  bus.write_byte(addrT, 0);
  bus.write_byte(addrC, 0);
  root.destroy()
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина i2c"
root = Tk(); root.geometry('122x42') # Создаем и настраиваем главное окно
root.protocol('WM_DELETE_WINDOW', wclose)
vC = IntVar() # Состояние чекбокса (контактора)
# Создаем объект - чекбокс
chC = Checkbutton(text = 'Контактор', command = fC, variable = vC)
pdm = 0 # Уровень pdm-модуляции
lpdm = Label(text = 'PDM (%) = ', width = 12, anchor = 'w') # Метка PDM
# Создаем объект - спинбокс
sbT = Spinbox(from_ = 0, to = 100, width = 3, command = fT, justify = RIGHT)
# Размещаем виджеты в главном окне
chC.place(x = 0, y = 0)
lpdm.place(x = 0, y = 20)
sbT.place(x = 80, y = 20)
root.mainloop() # Главный цикл приложения

#include <avr/io.h>
#include <util/twi.h>
#include <avr/interrupt.h>

#define F_CPU 16000000UL
#define ADDR 0x14      // Адрес устройства на шине I2C
                        
volatile uint16_t pwm = 0;  // Заданный ШИМ в полупериодах (десятых долях %)
volatile uint16_t wpwm;     // Рабочая переменная
static volatile uint8_t index = 0; // Номер байта (0 - младший, 1 - старший)
volatile uint16_t cntr = 0; // Счетчик полупериодов
//------------------------------------------------------------------------------
ISR(TWI_vect) { // Обработчик событий модуля TWI
 uint16_t w;
 switch(TW_STATUS) {    // Статус - в 5 старших битах регистра TWSR
   case TW_SR_DATA_ACK: // Данные приняты, ACK отправлен - 0x80
     w = TWDR;
     if(index) { // Принят старший байт. Значит формируем новое значение pwm
       w <<= 8; pwm = wpwm | w; index = 0;
       if(pwm > 1000) pwm = 1000;
     } else { // Принят младший байт - формируем младшие биты будущего pwm
       wpwm = w; index = 1;
     }
     break;
   case TW_ST_SLA_ACK:  // Запрос SLA+R, ACK отправлен - 0xA8
     TWDR = 0xff;       // По запросу - отправляем малинке кучу единичек (OK),
     index = 0;         // что означает, что контроллер готов принять два
     break;             // последовательных байта (начиная с младшего)
   case TW_BUS_ERROR:   // Неверные условия "старт" или "стоп" - 0x00
     TWCR = _BV(TWIE) | _BV(TWINT) | _BV(TWEA) | _BV(TWEN); // "Сброс" TWI
     break;
 }
 TWCR |= _BV(TWINT);   // Флаг TWINT здесь НЕ очищается автоматически! Очистим.
} 
//------------------------------------------------------------------------------
ISR(INT0_vect) { // Внешнее прерывание INT0 (Zero от детектора нуля)
 cntr++; // Считаем полупериоды
 if(cntr == 1000) { // 10 секунд (1000 полупериодов) прошло
   cntr = 0;   // Сбрасываем счетчик
   if(pwm > 0) // Включаем клапан (начало импульса ШИМ)
     PORTD |= _BV(PD0);
 }
 if(cntr >= pwm && (PORTD & _BV(PD0))) // Пора выключать клапан
   PORTD &= ~_BV(PD0);
 if(cntr < pwm && (~PORTD & _BV(PD0))) // Если pdm был изменен, но время
   PORTD |= _BV(PD0);                  // еще не истекло - откроем клапан
}
//------------------------------------------------------------------------------
int main(void) {
 DDRD = _BV(PD0); // Пин PD0 - на вывод (управление оптосимистором)
 // Инициализация TWI-модуля --------------------------------------------------
 TWAR = ADDR << 1;   // Адрес устройства - в старших 7 битах
 TWCR = _BV(TWIE);   // Разрешаем прерывания от TWI
 TWCR |= _BV(TWEA);  // Разрешаем подачу импульса ACK
 TWCR |= _BV(TWINT); // Очистим флаг TWINT (очищается при установке в 1)
 TWCR |= _BV(TWEN);  // Разрешаем работу TWI и активирует TWI-интерфейс
 // Инициализация внешнего прерывания INT0
 EICRA = _BV(ISC01) | _BV(ISC00); // Прерывания по фронту на пине PD2/INT0
 EIMSK = _BV(INT0); // Разрешаем внешние прерывания на пине PD2/INT0
 
 sei(); // Разрешаем глобальные прерывания
 while(1) { // Бесконечный цикл
 }
 return 0;
}

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
import kbh # В этом модуле - функция kbhit() для работы с клавиатурой
          # в неблокирующем режиме
#-------------------------------------------------------------------------------
# Тестирование прошивки контроллера ТЭНа
#-------------------------------------------------------------------------------
# 'q' - выход из программы
# Управление контроллером контактора:
# 'w' - включить контактор
# 's' - выключить контактор
# Управление контроллером ТЭНа:
# 'e' - увеличить уровень pdm
# 'd' - уменьшить уровень pdm
# 'r' - pdm - на 100%
# 'f' - pdm - в 0
# Управление контроллером клапана отбора:
# 't' - увеличить pwm на 0.1%
# 'g' - уменьшить pwm на 0.1%
# 'y' - увеличить pwm на 1%
# 'h' - уменьшить pwm на 1%
# 'u' - pwm - на 100%
# 'j' - pwm - в 0
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина i2c"
addrC = 0x12 # Адрес контроллера контактора
addrT = 0x13 # Адрес контроллера ТЭНа на шине i2c
addrV = 0x14 # Адрес контроллера клапана отбора на шине i2c
tt = kbh.TT(500) # Создаем объект - терминал, работающий в неблокирующем режиме
                # timeout = 500 ms
pdm = 0 # Уровень pdm (pulse density modulation, ака Брезенхем)
opdm = 0
pwm = 0 # Уровень ШИМ клапана отбора
opwm = 0
while True:
 if tt.kbhit(): # Была нажата какая-то клавиша
   ch = tt.getch() # Получаем введенный символ
   if ch == 'q': # Выход их программы - выключаем все
     bus.write_byte(addrC, 0) # Выключить контактор
     bus.write_byte(addrT, 0) # Выключить ТЭН
     bus.read_byte(addrV)     # Выключить клапан
     bus.write_byte(addrV, 0) 
     bus.write_byte(addrV, 0)
     break
   elif ch == 'w': bus.write_byte(addrC, 1) # Включим контактор
   elif ch == 's': bus.write_byte(addrC, 0) # Выключим контактор

   elif ch == 'e' or ch == '=': pdm += 1 # Увеличим уровень pdm
   elif ch == 'd' or ch == '-': pdm -= 1 # Уменьшим уровень pdm
   elif ch == 'r': pdm = 100    # Максимальный уровень pdm - 100%
   elif ch == 'f': pdm = 0      # Минимальный уровень pdm - 0%

   elif ch == 't': pwm += 1     # Увеличим уровень pwm на 0.1%
   elif ch == 'g': pwm -= 1     # Уменьшим уровень pwm на 0.1%
   elif ch == 'y': pwm += 10    # Увеличим уровень pwm на 1%
   elif ch == 'h': pwm -= 10    # Уменьшим уровень pwm на 1%
   elif ch == 'u': pwm = 1000   # Максимальный уровень pwm - 100%
   elif ch == 'j': pwm = 0      # Минимальный уровень pwm - 0%

 if pdm > 100: pdm = 100
 if pdm < 0: pdm = 0
 if opdm <> pdm: # Уровень pdm был изменен - покажем его
   bus.write_byte(addrT, pdm)   # Шлем уровень pdm контроллеру ТЭНа
   print 'pdm = ', pdm; opdm = pdm

 if pwm > 1000: pdm = 1000
 if pwm < 0: pwm = 0
 if opwm <> pwm: # Уровень pwm был изменен - пошлем его контроллеру и покажем
   print bus.read_byte(addrV)
   bus.write_byte(addrV, (pwm & 0xff))
   bus.write_byte(addrV, ((pwm >> 8) & 0xff))
   print 'pwm = ', pwm*0.1; opwm = pwm

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
from Tkinter import * # Инструментарий для GUI
import tkMessageBox as mbox # Чтобы ругаться
#-------------------------------------------------------------------------------
# Тестирование firmware контроллера ТЭНа
#-------------------------------------------------------------------------------
addrC = 0x12 # Адрес контроллера контактора
addrT = 0x13 # Адрес контроллера ТЭНа
addrV = 0x14 # Адрес контроллера клапана отбора на шине i2c
#-------------------------------------------------------------------------------
def fC(): # Вызывается при изменении состояния чекбокса
 global vC
 bus.write_byte(addrC, vC.get());
#-------------------------------------------------------------------------------
def fT(): # Вызывается при изменении состояния спинбокса ТЭНа
 global sbT, pdm
 pdm = int(sbT.get())
 bus.write_byte(addrT, pdm);
#-------------------------------------------------------------------------------
def fV(): # Вызывается при изменении состояния спинбокса клапана отбора
 global sbV, pwm
 pwm = int(sbV.get())*10
 if(bus.read_byte(addrV) == 0xff):
   bus.write_byte(addrV, (pwm & 0xff))
   bus.write_byte(addrV, ((pwm >> 8) & 0xff))
 else:mbox.showerror('Ошибка', 'Ошибка контроллера клапана отбора')
#-------------------------------------------------------------------------------
def wclose(): # Перед закрытием главного окна приложения выключим все
 bus.read_byte(addrV)      # Выключить клапан
 bus.write_byte(addrV, 0) 
 bus.write_byte(addrV, 0)
 bus.write_byte(addrT, 0); # Выключаем ТЭН
 bus.write_byte(addrC, 0); # Выключаем контактор
 root.destroy()
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина i2c"
root = Tk(); root.geometry('122x62') # Создаем и настраиваем главное окно
root.protocol('WM_DELETE_WINDOW', wclose)
vC = IntVar() # Состояние чекбокса (контактора)
# Создаем объект - чекбокс
chC = Checkbutton(text = 'Контактор', command = fC, variable = vC)
pdm = 0 # Уровень pdm-модуляции для контроллера ТЭНа
lpdm = Label(text = 'ТЭН (%) = ', width = 13, anchor = 'w') # Метка PDM
# Создаем объект - спинбокс
sbT = Spinbox(from_ = 0, to = 100, width = 3, command = fT, justify = RIGHT)
pwm = 0 # Уровень pwm-модуляции для контроллера клапана отбора
lpwm = Label(text = 'Клапан (%) = ', width = 13, anchor = 'w') # Метка ШИМ
# Создаем объект - спинбокс
sbV = Spinbox(from_ = 0, to = 100, width = 3, command = fV, justify = RIGHT)
# Размещаем виджеты в главном окне
chC.place(x = 0, y = 0)
lpdm.place(x = 0, y = 20)
sbT.place(x = 80, y = 20)
lpwm.place(x = 0, y = 40)
sbV.place(x = 80, y = 40)
root.mainloop() # Главный цикл приложения