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

Рабочее напряжение: 4.8-6.6 В (постоянное, DC)
Рабочий ток: 170 - 900 мА
Скорость реакции без нагрузки:
    0.1 секунды / 60° (4.8 вольт)
    0.08 секунды / 60° (6.0 вольт)
Угол поворота: до 160°
Управление: ШИМ
Контроллер: аналоговый, АА51880
Редуктор: латунь, алюминиевый сплав
Расположение редуктора и мотора: параллельные оси вращения
Тип редуктора: шестеренчатая цилиндрическая передача
Блокирующий момент:
    1.8 кг / см (4.8 вольт)
    2.2 кг / см (6.6 вольт)
Длина кабеля: 25 см
Размеры: 22.8 х 12.2 х 28.4 мм
Температура эксплуатации: 0°С...+55°С
Водонепроницаемость: нет
Вес: 13.4 гр

//------------------------------------------------------------------------------
// Прошивка для привода сервомашинок
// Код семейства - 0xA9
// Адрес на шине i2c - 0x19
// OldBean, 04.10.2019
//------------------------------------------------------------------------------
#include <avr/io.h>
#include <util/twi.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <string.h>
//------------------------------------------------------------------------------
#define F_CPU 16000000UL // Тактовая частота МК
#include <util/delay.h>
//------------------------------------------------------------------------------
#define ADDR 0x19        // Адрес устройства на шине I2C
#define FAMILY_CODE 0xA9 // Код семейства данного устройства
#define BUF_SIZE 32      // Размер буфера обмена данными
#define EE_SIZE 6        // Размер блока идентиф. и калибр. данных
//------------------------------------------------------------------------------
// Команды:
// 0x33 Чтение кода семейства
// 0x4e Записать данные из буфера обмена в рабочую область (write scratch)
// 0xbe Считать данные из рабочей области в буфер обмена (read scratch)
// 0x48 Записать блок данных из рабочей области в EEPROM (copy scratch)
// 0xb8 Считать блок данных из EEPROM в рабочую область (recall EEPROM)
// 0x52 Запись данных в рабочие регистры (для контроллеров)
//------------------------------------------------------------------------------
#define ZERO_START 106 // Определяет задержку фронта импульса Zero
#define ZERO_WIDTH 13  // Определяет ширину импульса Zero (100 мкс)
#define T_ADC 49       // Определяет интервал между запусками АЦП (200 мкс)
#define SUM_MAX 5000   // Количество суммируемых отсчетов (5000 - это за 1 сек)
//------------------------------------------------------------------------------
static uint8_t buf[BUF_SIZE];        // Буфер обмена
static uint8_t scratch[BUF_SIZE];    // Рабочая область RAM
static volatile uint8_t *ptr;        // Указатель на байт буфера обмена
static volatile uint8_t runFlag = 1; // Рабочий режим, 0 - режим настройки
static volatile uint8_t nb = 0;      // Счетчик байтов
static volatile uint8_t prFlag = 0;  // Принят новый пакет байтов
static volatile uint8_t cmd = 0x00;  // Код команды
static volatile uint16_t pwm;        // Текущий уровень  PWM
static uint16_t pwma[] = {120, 287, 453, 620}; // Уровни PWM для разных углов поворота сервы
//------------------------------------------------------------------------------
ISR(TWI_vect) { // Обработчик событий модуля TWI
  switch(TW_STATUS) {     // Статус - в 5 старших битах регистра TWSR
    // Принимаем байты
    case TW_SR_SLA_ACK:   // Адрес для приема принят, ACK отправлен - 0x80
      ptr = buf;          // Настраиваемся на начало буфера обмена
      nb = 0;             // Сброс счетчика байтов
      break;
    case TW_SR_DATA_ACK:  // Очередной байт принят, ACK отправлен - 0x80
      *ptr++ = TWDR;
      nb++;
      break;
    case TW_SR_STOP:      // Состояние "стоп" на шине - 0xA0
      prFlag = 1;         // Новый пакет принят
      break;
    // Отправляем байты
    case TW_ST_SLA_ACK:   // Адрес для отправки принят, ACK отправлен - 0xA8
      ptr = buf;          // Настраиваемся на начало буфера обмена
      nb = 0;             // Сброс счетчика байтов
    case TW_ST_DATA_ACK:  // Очередной байт отправлен, ACK принят - 0xB8
      TWDR = *ptr++;
      nb++;
      break;
    case TW_ST_DATA_NACK: // Байт отправлен и получен NACK - 0xC0
    case TW_ST_LAST_DATA: // Отправлен последний байт, получен ACK - 0xC8
      break;
    // Ошибки старта или стопа - сброс TWI
    case TW_BUS_ERROR:
      TWCR = _BV(TWIE) | _BV(TWINT) | _BV(TWEA) | _BV(TWEN);
      break;
  }
  TWCR |= _BV(TWINT); // Очистим флаг TWINT (очищается при установке в 1)
}
//------------------------------------------------------------------------------
void delay_ms(uint8_t count) {
  while(count--) {
    _delay_ms(1);
  }
}
//------------------------------------------------------------------------------
int main(void) {
  DDRB = _BV(PB0) | _BV(PB1) | _BV(PB2); // Пины PB0 - PB2 - на вывод
  // Инициализация TWI-модуля --------------------------------------------------
  TWAR = ADDR << 1;   // Адрес устройства - в старших 7 битах
  TWCR = _BV(TWIE);   // Разрешаем прерывания от TWI
  TWCR |= _BV(TWEA);  // Разрешаем подачу импульса ACK
  TWCR |= _BV(TWINT); // Очистим флаг TWINT (очищается при установке в 1)
  TWCR |= _BV(TWEN);  // Разрешаем работу TWI и активирует TWI-интерфейс
  // Инициализация таймера 1 для PWM -------------------------------------------
  TCCR1A |= (1<<COM1A1) | (1<<COM1B1); // None-inverted mode
  TCCR1A |= (1<<WGM11); // и ниже - Fast PWM
  TCCR1B |= (1<<WGM13) | (1<<WGM12);
  TCCR1B |= (1<<CS11)|(1<<CS10); // Делитель 64,
  ICR1 = 4999; // Частота - 50 Гц при таком ICR1

  pwm = pwma[0];
  OCR1A = pwm;
  volatile uint16_t oldpwm, i;
  volatile int8_t step; // Направление вращения
  uint8_t dt; // Пошаговая задержка в мс

  sei(); // Разрешаем глобальные прерывания
  ptr = buf;
  while(1) { // Бесконечный цикл
    if(prFlag) { // По шине i2c принят новый пакет - отрабатываем его
      TWCR &= ~_BV(TWEN); // Приостановим работу TWI
      prFlag = 0; // Сбросим флаг получения нового пакета
      cmd = buf[0]; // Код команды
      switch(cmd) { // Анализируем и выполняем команды
        case 0x33: // Чтение ROM - в первом байте - код семейства
          buf[0] = FAMILY_CODE;
          break;
        case 0x4e: // write scratch - записать данные в рабочую область
          memcpy(scratch, &buf[1], EE_SIZE);
          break;
        case 0xbe: // read scratch - считать данные из рабочей области
          memcpy(buf, scratch, EE_SIZE);
          break;
        case 0x48: // copy scratch - записать блок данных в EEPROM
          eeprom_update_block((const void *)scratch, (void *)0, EE_SIZE);
          break;
        case 0xb8: // recall EEPROM - считать блок данных в EEPROM
          eeprom_read_block((void *)scratch, (const void*)0, EE_SIZE);
          break;
        case 0x52: // Команда управления
          cli(); // Запрещаем прерывания
          oldpwm = pwm; // Сохраняем старое значение PWM
          pwm = buf[2];
          pwm = (pwm << 8) | buf[1]; // Принятое (новое) значение PWM
          if(pwm < 4) pwm = pwma[pwm]; // Для малых значений берем из массива
          dt = buf[3]; // Пошаговая задержка для более медленного вращения
          if(dt) {
            step = (pwm > oldpwm)? 1: -1; // Направление шагов
            i = oldpwm + 1;
            while(1) { // Двигаемся плавно, чтобы не выдернуть шланик
              OCR1A = i;
              if(i == pwm) break;
              i += step;
              delay_ms(dt);
            }
          } else { // Быстрое перемещение (dt == 0)
            OCR1A = pwm;
          }
          sei(); // Разрешаем прерывания
          break;
      }
      TWCR |= _BV(TWEN); // Активируем TWI
    }
  }
  return 0;
}
//------------------------------------------------------------------------------
// История и список изменений
// 1. 05.10.2019 - Отлажен весь функционал для этого типа устройств.
//------------------------------------------------------------------------------

#-------------------------------------------------------------------------------
class MG90S(I2C):
  ''' Привод сервомашинки MG90S
  '''
  fc = 0xA9
  def __init__(self, addr):
    '''
    __init__(self, addr)
    Конструктор. addr - адрес на шине i2c
    '''
    I2C.__init__(self, addr) # Инициализируем i2c в родительском классе
    self._calibr = self.rc()
#    self._calibr = [0.3688, 90, 0] # Калибровочные данные
    self.coefi = 1.0/self._calibr[0] # Обратная величина от коэффициента
    self.delay = 0 # Пошаговая пауза для замедления вращения в мс
    self.val = 0.0

  def rc(self):
    '''
    rc()
    Читает с устройства калибровочные данные
    '''
    self.wd(b'\xb8') # Команда - считать блок данных из EEPROM
    self.wd(b'\xbe') # Команда - считать данные из рабочей области
    buf = self.rd(EE_SIZE) # Считаем калибровку
    return deser(buf) # Распаковка блока

  def wc(self, coef = 1.0, offset = 0, ui = 0):
    '''
    wc(self, coef = 1.0, offset = 0, ui = 0)
    Запись калибровочных данных в EEPROM
      coef - калибровочный коэффициент для получения физ. величины из кода
      offset - смещение кода АЦП
      ui - индекс единицы измерения физической величины в списке units
    '''
    buf = b'\x4e' # Команда записать данные в рабочую область
    buf += ser(coef, offset, ui)
    self.wd(buf) # Запись калибровок в рабочую память устройства
    self.wd(b'\x48') # Команда записать блок данных в EEPROM

  @property
  def calibr(self):
    '''Возвращает калибровочные данные'''
    return self._calibr

  @calibr.setter
  def calibr(self, value):
    '''Записывает калибровочные данные в устройство. Калибровочные данные
    должны быть указаны в формате [coef, offset, ui], где coef - калибровочный
    коэффициент, offset - смещение, ui - индекс единицы измерения.'''
    self.wc(*value)
    self._calibr = value # Обновим калибровку
    self.coefi = 1/self._calibr[0]
    pass

  @property
  def code(self):
    '''
    Свойство code - уровень ШИМ
    '''
    return self._code

  @code.setter
  def code(self, value):
#    if value > maximum?: value = maximum?
    if value < 0: value = 0.0
    buf = bytearray();
    buf.append(0x52)
    buf.append(value & 0xff)
    buf.append((value >> 8) & 0xff)
    buf.append(self.delay & 0xff)
    self.wd(buf)
    self._code = value
    self._val = (self._code - self._calibr[1])*self._calibr[0]

  @property
  def val(self):
    return self._val

  @val.setter
  def val(self, value):
    self.code = int(value*self.coefi + 0.5) + self._calibr[1]

  # Просто "затычки" для единообразия
  @property
  def v(self):
    return self.val

  @val.setter
  def v(self, value):
    self.val = value
#-------------------------------------------------------------------------------