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

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

#define F_CPU 16000000UL

#define ADDR 0x11      // Адрес устройства на шине I2C
#define ZERO_START 106 // Определяет задержку фронта импульса Zero
#define ZERO_WIDTH 13  // Определяет ширину импульса Zero (100 мкс)
#define T_ADC 49       // Определяет интервал между запусками АЦП (200 мкс)
#define SUM_MAX 5000   // Количество суммируемых отсчетов (5000 - это за 1 сек)
                         
static volatile uint8_t index = 0; // Номер отправляемого байта
static volatile uint8_t buf[4];    // Буфер обмена. Младший байт - в начале (0)
static volatile uint32_t sum;      // Сумматор квадратов отсчетов АЦП
static volatile uint16_t sc = 0;   // Счетчик просуммированных квадратов

static volatile uint8_t zFlag = 0; // Разрешение формирования импульсов Zero
//------------------------------------------------------------------------------
ISR(TWI_vect) { // Обработчик событий модуля TWI
  switch(TW_STATUS) {    // Статус - в 5 старших битах регистра TWSR
    case TW_SR_DATA_ACK: // Данные приняты, ACK отправлен - 0x80
      index = 0; // При любом приеме index сбрасываем на первый байт буфера
      break;
    case TW_ST_SLA_ACK:  // Запрос SLA+R, ACK отправлен - 0xA8
      TWDR = buf[index++]; // Очередной байт - в регистр данных TWI
      if(index == 4) index = 0; // Весь буфер отправлен - вернемся к его началу
      break;
    case TW_BUS_ERROR:   // Неверные условия "старт" или "стоп" - 0x00
      TWCR = _BV(TWIE) | _BV(TWINT) | _BV(TWEA) | _BV(TWEN); // "Сброс" TWI
      break;
  }
  TWCR |= _BV(TWINT);   // Флаг TWINT здесь НЕ очищается автоматически! Очистим.
} 
//------------------------------------------------------------------------------
ISR(TIMER0_COMPA_vect) { // Обработчик по совпадению с регистром A
  ADCSRA |= _BV(ADSC); // Запуск преобразования
}
//------------------------------------------------------------------------------
ISR(ADC_vect) { // Преобразование закончено
  register uint32_t val = ADCL; val |= ((uint32_t)ADCH) << 8;
  sei(); // Следующие фрагменты не требуют атомарности; разрешим прерывания
  sum += val*val; // Суммирование квадратов кода АЦП - 6 мкс
  if(++sc == SUM_MAX) { // Насуммировали достаточно
    register uint32_t csum = sum;
    // Занесем полученную сумму квадратов кода АЦП в буфер обмена
    buf[0] = csum & 0xFF; csum >>= 8;
    buf[1] = csum & 0xFF; csum >>= 8;
    buf[2] = csum & 0xFF; csum >>= 8;
    buf[3] = csum & 0xFF;
    sc = 0; sum = 0; // Сбрасываем счетчик и сумматор
  }
}
//------------------------------------------------------------------------------
ISR(INT0_vect) { // Внешнее прерывание на пине PB2/INT0
  GTCCR = _BV(PSRASY); // Сброс предделителя таймера 2
  TCNT2 = 0; // Обнуляем счетчик таймера 2
  zFlag = 1; // Разрешаем формирование импульса Zero
}
//------------------------------------------------------------------------------
ISR(TIMER2_COMPA_vect) { // Обработчик по совпадению с регистром A
  if(!zFlag) return;
  PORTB |= _BV(PB0); // Формируем фронт импульса на шине Zero
}
//------------------------------------------------------------------------------
ISR(TIMER2_COMPB_vect) { // Обработчик по совпадению с регистром B
  if(!zFlag) return;
  PORTB &= ~_BV(PB0); // Формируем спад импульса на шине Zero
  zFlag = 0; // Запрещаем формирование "ложных" импульсов Zero
}
//------------------------------------------------------------------------------
int main(void) {
  DDRB = _BV(PB0); // Пин PB0 - на вывод (сигнал Zero)
  DDRB |= _BV(PB1); // Пин PB1 используется для диагностических целей
  // Инициализация TWI-модуля --------------------------------------------------
  TWAR = ADDR << 1;   // Адрес устройства - в старших 7 битах
  TWCR = _BV(TWIE);   // Разрешаем прерывания от TWI
  TWCR |= _BV(TWEA);  // Разрешаем подачу импульса ACK
  TWCR |= _BV(TWINT); // Очистим флаг TWINT (очищается при установке в 1)
  TWCR |= _BV(TWEN);  // Разрешаем работу TWI и активирует TWI-интерфейс
  // Инициализация таймера 0 для тактирования АЦП ------------------------------
  TCCR0A = _BV(WGM01); // Счетчик работает в режиме CTC (сброс по совпадению)
  TCCR0B = _BV(CS01) | _BV(CS00); // Предделитель на 64 (на счетчик - 250 кГц)
  OCR0A = T_ADC; // Определяет период запуска АЦП
  TIMSK0 |= _BV(OCIE0A); // Разрешаем прерывания по совпадению с OCR0A
  // Инициализация АЦП ---------------------------------------------------------
  ADMUX = 0; // Канал 0 (ADC0), MUX3...0 = 0
  ADMUX = _BV(REFS1) | _BV(REFS0); // Внутр. источник опорного напряжения 1.1V
  ADCSRA = _BV(ADEN); // АЦП включен
  ADCSRA |= _BV(ADIE); // По окончанию преобразования - прерывание
  ADCSRA |= _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0); // Предделитель на 128
  // Инициализация внешнего прерывания INT0
  EICRA = _BV(ISC01); // Прерывания по спаду уровня на пине PD2/INT0
  EIMSK = _BV(INT0); // Разрешаем внешние прерывания на пине PD2/INT0
  // Инициализация таймера 2 для формирования импульса нуля Zero
  // Счетчик работает в обычном режиме (Normal mode)
  TCCR2B |= _BV(CS22) | _BV(CS20); // Предделитель на 128 (сч. - 125 кГц)
  OCR2A = ZERO_START; // Фронт импульса Zero
  OCR2B = ZERO_START + ZERO_WIDTH; // Спад импульcа Zero
  TIMSK2 = _BV(OCIE2A) | _BV(OCIE2B); // Разрешаем прерывания по совпадению
  
  sei(); // Разрешаем глобальные прерывания
  while(1) { // Бесконечный цикл
  }
  return 0;
}

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
import math # В этом модуле математические функции 
#-------------------------------------------------------------------------------
# Тестирование и калибровка датчика RMS. 
# OldBean, 26.01.2018
#-------------------------------------------------------------------------------
addrR = 0x11 # Адрес датчика RMS
a = 0.3838 # Калибровочный коэффициент для перевода кода в вольты
cntr = 0 # Счетчик измерений RMS напряжения сети
#-------------------------------------------------------------------------------
def meas(): # Получение кода и вычисление RMS
  global cntr; cntr += 1 # Модифицируем счетчик измерений
  bus.write_byte(addrR, 0); # Установка индекса байтов в датчике RMS на 0
  crms = bus.read_byte(addrR)        # Читаем 4 байта с датчика RMS (начиная с
  crms |= bus.read_byte(addrR) << 8  # младшего и собираем 32-разрядное слово
  crms |= bus.read_byte(addrR) << 16 # В этом слове - сумма квадратов кода АЦП
  crms |= bus.read_byte(addrR) << 24 # за 1 сек (5000 отсчетов)
  v = a*math.sqrt(crms*0.0002)  # Вычисляем RMS (0.0002 это 1/5000)
  print "%d\t%d\t%.1f" % (cntr, crms, v) 
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина"
cntr = 0 # Счетчик отсчетов RMS напряжения сети
while True:
  meas() # Получаем код от датчика RMS, вычисляем RMS и выводим из на терминал
  time.sleep(1) # Секундочку подремлем

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
import math # В этом модуле математические функции (sqrt, в частности)
from Tkinter import * # В этом модуле виджеты для GUI
#-------------------------------------------------------------------------------
# Тестирование и калибровка датчика RMS. 
# OldBean, 26.01.2018
#-------------------------------------------------------------------------------
addrR = 0x11 # Адрес датчика RMS
a = 0.3838 # Калибровочный коэффициент для перевода кода в вольты
cntr = 0 # Счетчик измерений RMS напряжения сети
#-------------------------------------------------------------------------------
def meas(): # Получение кода и вычисление RMS
  global cntr; cntr += 1 # Модифицируем счетчик измерений
  bus.write_byte(addrR, 0); # Установка индекса байтов в датчике RMS на 0
  crms = bus.read_byte(addrR)        # Читаем 4 байта с датчика RMS (начиная с
  crms |= bus.read_byte(addrR) << 8  # младшего и собираем 32-разрядное слово
  crms |= bus.read_byte(addrR) << 16 # В этом слове - сумма квадратов кода АЦП
  crms |= bus.read_byte(addrR) << 24 # за 1 сек (5000 отсчетов)
  v = a*math.sqrt(crms*0.0002)  # Вычисляем RMS (0.0002 это 1/5000)
  txtCntr.configure(text = "%d " % (cntr)) # Выводим значение счетчика
  txtCode.configure(text = "%d " % (crms)) # Выводим значение кода
  txtRMS.configure(text = "%.1f " % (v)) # Выводим значение RMS
  txtCode.after(1000, meas) # Через 1 сек (1000 мс) опять вызовем meas
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина"
# Создаем объекты GUI
root = Tk(); root.geometry('134x60'); root.title('RMS') # Главное окно
labCntr = Label(text = 'Измерений = ', width = 12) # Метка окна счетчика
txtCntr = Label(width = 5, anchor = 'e') # Окно вывода счетчика
labCode = Label(text = 'Код = ', width = 6) # Метка окна кода
txtCode = Label(width = 10, anchor = 'e') # Окно вывода кода
labRMS = Label(text = 'RMS = ', width = 6) # Метка окна RMS
txtRMS = Label(width = 5, anchor = 'e') # Окно вывода RMS
# Размещаем виджеты в главном окне
labCntr.place(x = 0, y = 0); txtCntr.place(x = 90, y = 0)
labCode.place(x = 0, y = 20); txtCode.place(x = 50, y = 20)
labRMS.place(x = 0, y = 40); txtRMS.place(x = 90, y = 40)

txtCode.after(1000, meas) # Через 1 сек (1000 мс) будет вызов функции meas
root.mainloop() # Главный цикл приложения

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
import math # В этом модуле математические функции (sqrt, в частности)
from Tkinter import * # В этом модуле виджеты для GUI
import tkMessageBox as mbox # Чтобы ругаться
#-------------------------------------------------------------------------------
# Тестирование и калибровка датчика RMS. 
# OldBean, 26.01.2018
#-------------------------------------------------------------------------------
addrR = 0x11 # Адрес датчика RMS
a = 0.3838 # Калибровочный коэффициент для перевода кода в вольты
cntr = 0 # Счетчик измерений RMS напряжения сети
crms = 0 # Код, получаемый от датчика RMS
#-------------------------------------------------------------------------------
def meas(): # Получение кода и вычисление RMS
  global crms, cntr; cntr += 1 # Модифицируем счетчик измерений
  bus.write_byte(addrR, 0); # Установка индекса байтов в датчике RMS на 0
  crms = bus.read_byte(addrR)        # Читаем 4 байта с датчика RMS (начиная с
  crms |= bus.read_byte(addrR) << 8  # младшего и собираем 32-разрядное слово
  crms |= bus.read_byte(addrR) << 16 # В этом слове - сумма квадратов кода АЦП
  crms |= bus.read_byte(addrR) << 24 # за 1 сек (5000 отсчетов)
  v = a*math.sqrt(crms*0.0002)  # Вычисляем RMS (0.0002 это 1/5000)
  txtCntr.configure(text = "%d " % (cntr)) # Выводим значение счетчика
  txtCode.configure(text = "%d " % (crms)) # Выводим значение кода
  txtRMS.configure(text = "%.1f " % (v)) # Выводим значение RMS
  txtA.configure(text = "%.4f " % (a)) # Выводим калибровочный коэффициент
  txtCode.after(1000, meas) # Через 1 сек (1000 мс) опять вызовем meas
#-------------------------------------------------------------------------------
def calc(): # Вычисление калибровочного коэффициента a
  global a, crms
  try: # Попытаемся считать введенное образцовое напряжение
    v = float(sa.get()) # Преобразуем строку в число (успешно)
    if v > 100 and v < 300: # Если оно в разумном диапазоне - работаем дальше
      a = v/math.sqrt(crms*0.0002) # Вычисляем калибровочный коэффициент
    else: # Выход за границы допустимого диапазона
      mbox.showerror('Ошибка', 'Заданное напряжение выходит за границы диапазона (100-300 В)')
  except ValueError: # Обработка исключения (введено не число)
    mbox.showerror('Ошибка', 'Введите число - среднеквадратичное напряжение сети в вольтах')
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина"

# Создаем объекты GUI
root = Tk(); root.geometry('136x132'); root.title('RMS') # Главное окно
labCntr = Label(text = 'Измерений = ', width = 12) # Метка окна счетчика
txtCntr = Label(width = 5, anchor = 'e') # Окно вывода счетчика
labCode = Label(text = 'Код = ', width = 6) # Метка окна кода
txtCode = Label(width = 11, anchor = 'e') # Окно вывода кода
labRMS = Label(text = 'RMS = ', width = 6) # Метка окна RMS
txtRMS = Label(width = 5, anchor = 'e') # Окно вывода RMS
fr = Frame(width = 134, height = 1, bg = 'red')
labRMSm = Label(text = 'Изм RMS = ', width = 10) # Метка окна измеренного RMS
# entRMSm - это окошечко для ввода RMS, измеренного образцовым вольтметром,
# а sa - это переменная, непосредственно связанная с содержимым этого окна
sa = StringVar(); sa.set('0')
entRMSm = Entry(width = 5, justify = RIGHT, textvariable = sa)
labA = Label(text = 'Коэф. = ', width = 8) # Метка окна измеренного RMS
txtA = Label(width = 6, anchor = 'e') # Окно вывода RMS
but = Button(text = 'Вычисл. коэф.', command = calc)

# Размещаем виджеты в главном окне
labCntr.place(x = 0, y = 0); txtCntr.place(x = 90, y = 0)
labCode.place(x = 0, y = 20); txtCode.place(x = 42, y = 20)
labRMS.place(x = 0, y = 40); txtRMS.place(x = 90, y = 40)
fr.place(x = 0, y = 60)
labRMSm.place(x = 0, y = 62); entRMSm.place(x = 88, y = 62)
labA.place(x = 0, y = 82); txtA.place(x = 80, y = 82)
but.place(x = 8, y = 102)

txtCode.after(1000, meas) # Через 1 сек (1000 мс) будет вызов функции meas
root.mainloop() # Главный цикл приложения

# _*_ coding: utf8 _*_
import time # В этом модуле - задержки
import smbus # В этом модуле - средства для работы с шиной i2c
import math # В этом модуле математические функции
#-------------------------------------------------------------------------------
# Тестирование и калибровка датчика RMS
# OldBean, 26.01.2018
#-------------------------------------------------------------------------------
addrR = 0x11 # Адрес датчика RMS
a = 0.3838 # Калибровочный коэффициент для перевода кода в вольты
cntr = 0 # Счетчик измерений RMS напряжения сети
stime = 1.0 # Длительность паузы
#-------------------------------------------------------------------------------
def meas(): # Возвращает код, полученный от датчика RMS
  bus.write_byte(addrR, 0); # Установка индекса байтов в датчике RMS на 0
  crms = bus.read_byte(addrR)        # Читаем 4 байта с датчика RMS (начиная с
  crms |= bus.read_byte(addrR) << 8  # младшего и собираем 32-разрядное слово
  crms |= bus.read_byte(addrR) << 16 # В этом слове - сумма квадратов кода АЦП
  crms |= bus.read_byte(addrR) << 24 # за 1 сек (5000 отсчетов)
  return crms
#-------------------------------------------------------------------------------
bus = smbus.SMBus(1) # Создаем объект "шина"
cntr = 0 # Счетчик отсчетов RMS напряжения сети
while True:
  crms = meas() # Получаем код от датчика RMS, вычисляем RMS и выводим из на терминал
  cntr += 1
  v = a*math.sqrt(crms*0.0002)  # Вычисляем RMS (0.0002 это 1/5000)
  print "%d\t%d\t%.1f" % (cntr, crms, v)
  if v > 100.0: # Сеть есть
    if stime > 1.0: # А точнее - появилась
      print 'Сеть появилась - работаем...'
      stime = 1.0 # Уменьшим паузы
  else: # Сети нет
    if stime < 10.0: # А точнее - пропала
      print 'Сеть пропала - отдыхаем...'
      stime = 10.0 # Увеличим паузы
  time.sleep(stime) # Подремлем...