Arduino.ru

Глубоко над этими вопросами пока не задумывался. Просто меня удивила простота и миниатюрность схемы регулятора размещенного в кнопке и регулирующая мощность 710 ватт. Там симистор, SMD кондерчик, SMD резистор, микроскопический динистор и переменник в виде двух полосок. А в кнопке которую я купил на замену и изломал, схема еще проще.

Я со своим двигателем пока тоже затормазил. Схема схожая. Проблемы в том, что нужны стабильные низкие обороты. При датчике, который даёт 8 импульсов за оборот, достичть стабильности на низких оборотах сложно, нашёл опрический датчик с перфорацией на 36 отверстий по окружности. С 65 герцами париться не стоит, будет работать и на 50 я проверял.

Не претендую на истину, но мне кажется что для управления двигателем лучше просто электронный блок с обратной связью от двигателя и быстрой реакцией. Должно быть как можно проще, а следовательно и надежно. Думаю, что ардуину здесь прикручивать не стоит....ну разве что для украшения.....ну там..режимы...обороты ....ток....цветные лампочки....

Как реализовать управление симистором без функции "Делей"?

Грузит всё особенно на малых оборотах.

{
  // Firing angle calculation : 1 full 50Hz wave =1/50=20ms 
  // Every zerocrossing thus: (50Hz)-> 10ms (1/2 Cycle) For 60Hz => 8.33ms 
  // 10ms=10000us
  // (10000us - 10us) / 128 = 75 (Approx) For 60Hz =>65
  int dimtime = (75*dimming);    // For 60Hz =>65    
  delayMicroseconds(dimtime);    // Off cycle
  digitalWrite(AC_LOAD, HIGH);   // triac firing
  delayMicroseconds(10);         // triac On propogation delay (for 60Hz use 8.33)
  digitalWrite(AC_LOAD, LOW);    // triac Off
}

 

у меня такой код без делая. поковыряйся может поможет:

// TRIAC
#define triac_control 12 // Triac control - pin
#define open_loop 13 // open loop control (no PID)
//RPM control
#define sensorPin A1 // potentiometer or MACH3 - pin

//Power
#define powerOn 4 // manual motor switch - pin

//Zero Detect
#define zero_detect 2 //Zero detect - pin
// when using values in the main routine and IRQ routine must be volatile value
volatile byte zero_byte = LOW; // declare IRQ flag
// HIGH = 1, LOW = 0

// HALL SENSOR
#define hallsensor 3 // hall or optical sensor pin
#define hallsensor2 A4 // to check signal on hall or optical sensor pin
unsigned int rpmcount;
unsigned int rpm;
unsigned long timeold;
unsigned long time1;

//LCD
//LiquidCrystal::LiquidCrystal(rs, enable, d0, d1, d2, d3)
#include <Wire.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(5, 6, 7, 8, 9, 10);

//INTERRUPT
#include <avr/io.h>
#include <avr/interrupt.h>
#define PULSE 24 // pulse length on triac control pin
//in timer cycles (1/64 prescalar=> 4us per cycle=>96us)
// PID
#include <PID_v1.h>

//Define Variables we'll be connecting to
double Setpoint, Input, Output;

//Define the aggressive and conservative Tuning Parameters
//double consKp=4, consKi=0.2, consKd=1;
//double consKp=0.4, consKi=0.001, consKd=1;
//double consKp=4, consKi=0.2, consKd=1;
//double consKp=1, consKi=0.4, consKd=0.01; //100% work
//double consKp=0.4, consKi=0.001, consKd=1;
double consKp=1, consKi=0.4, consKd=0.01;

//Specify the links and initial tuning parameters
PID myPID(&Input, &Output, &Setpoint, consKp, consKi, consKd, DIRECT);
int sensorValue=0;
unsigned int analogValue=0;
unsigned int delayValue=8000;
unsigned int rpmmin = 6000; // Minimum and max rpm for the motor
unsigned int rpmmax = 35000;
unsigned int analogmin = 1; // analogmin and analogmax are the range of delay
unsigned int analogmax = 1023;// time and fot each motor must be determined empirically

void setup() {

//Triac control setup
pinMode(triac_control, OUTPUT);
digitalWrite(triac_control, 0); // triac and LED off
pinMode(open_loop, INPUT);
digitalWrite(open_loop, 1);
//Power switch
pinMode(powerOn, INPUT);
digitalWrite(powerOn, 1); // pull up on
//Zero detect
pinMode(zero_detect, INPUT);
digitalWrite(zero_detect, 1); // pull up on
attachInterrupt(0, zero_fun, FALLING); // interrupt 0 digital pin 2 connected ZC circuit
// Hall sensor
pinMode(hallsensor2, INPUT);
pinMode(hallsensor, INPUT);
digitalWrite(hallsensor, 1); // pull up on
attachInterrupt(1, rpm_fun, FALLING); // interrupt 1 digital pin 3 connected hall sensor
rpmcount = 0;
rpm = 0;
timeold = 0;
// LCD detect
lcd.begin(16,2); // initialize the lcd
lcd.home (); // go home
lcd.print(" Hello ");
lcd.setCursor ( 0, 1 ); // go to the next line
lcd.print (" GOOD LUCK ");
delay(1000);
lcd.clear();

// set up TIMER1
OCR1A = 100; //initialize the comparator
TIMSK1 = 0x03; //enable comparator A and overflow interrupts
TCCR1A = 0x00; //timer control registers set for
TCCR1B = 0x00; //normal operation, timer disabled
// Serial.begin(9600);
//PID
Input = rpm;
Setpoint = analogValue;
//turn the PID on
myPID.SetMode(AUTOMATIC);
myPID.SetOutputLimits(analogmin,analogmax); //usage of this parameters instead of
// rpmmin and rpmmax lets use only one mapping
// in PID
}
void loop()
{
//motor switch and indicator = ON/OFF
if (!digitalRead(powerOn)) // manual or by PC
{
// digitalWrite(powerIndicator, 1);
zero_byte=HIGH;

///////////////RPM counter ///////////////////
//////////////////////////////////////////////////////////////
if ((millis()-timeold) >= 250)
{
//Update RPM every 250 millis, increase this for better RPM resolution,
//decrease for faster update
//rpm = 60*1000/(millis() - timeold)*rpmcount;
unsigned long time = millis() - timeold;
float time_in_sec = (float)time / 1000;
float impuls_time = (float)rpmcount / time_in_sec;
rpm = (int)impuls_time*60;
rpmcount = 0; //reset
timeold = millis(); //reset time

}
//#######################PID ###############################
//##########################################################
analogValue = analogRead(sensorPin);
int analogLevel = map(analogValue,23,833, analogmin,analogmax);
//here we convert the voltage on pot to delay value
// 23-833 is the range of voltages that I got from my pot (in 0-1023 scale)
analogValue = analogLevel;

if (digitalRead(open_loop)==1)
{ Input = map(rpm, rpmmin,rpmmax,analogmin,analogmax);
// Here we put correspondance between rpm and delay values)
Setpoint = analogValue;
myPID.Compute();
analogValue = Output;
}
analogValue = analogmax-analogValue+analogmin;
// this inverts the delay values- higher rpm corrsponds to shorter delay times.
if (analogValue > analogmax)
{analogValue = analogmax;}
if (analogValue < analogmin)
{analogValue = analogmin;}
delayValue=analogValue; // we need this as during a cycle of PID
//calculations analogvalue changes several times
//??????????????????TRIAC delay control ???????????????????

OCR1A = delayValue/4;

//**************indicator ************************

if (rpm < 10)
{
lcd.setCursor ( 0, 0 );
lcd.print(" ");
lcd.print (rpm);}
if (10<= rpm && rpm < 100)
{
lcd.setCursor ( 0, 0 );
lcd.print(" ");
lcd.print (rpm);}
if (100<= rpm &&rpm < 1000)
{
lcd.setCursor ( 0, 0 );
lcd.print(" ");
lcd.print (rpm); }
if (1000<= rpm && rpm < 10000)
{
lcd.setCursor ( 0, 0 );
lcd.print(" ");
lcd.print (rpm);
}
if (10000<= rpm)
{
lcd.setCursor ( 0, 0 );
lcd.print (rpm);}
lcd.setCursor ( 7, 0 );
lcd.print ("RPM");
//////// output power indicator ///////////////////////////////
// max power 13 bars min power bars
lcd.setCursor ( 0, 1 );
lcd.print(" ");
lcd.setCursor ( 0, 1 );
int Level = map(delayValue,analogmin,analogmax, 13, 0);
// if the array element's index is less than ledLevel,
// turn the pin for this element on:
for (int bar = 0; bar < 13; bar++)  {
if (bar < Level)  {lcd.print(0);}
 }
}
else
// when motor is OFF, the display allows to check the input of Hall sensor
//(or optical level)
{
// digitalWrite(powerIndicator, 0);
zero_byte=LOW;
if (millis()-time1 >=10)
{ sensorValue = analogRead(hallsensor2);
//lcd.setCursor ( 0, 1 );
//lcd.print(" ");
lcd.clear();
lcd.setCursor ( 0, 1 );
int sensLevel = map(sensorValue,20,1000, 0, 13);
// values 20,1000 is the output voltage range of sensor in 0-1023 scale (0-5V),
// change them according to your sensor's output
for (int sbar = 0; sbar < 13; sbar++)  {
if (sbar < sensLevel)  { lcd.print(0);}
}
time1=millis();
}
}
} // end of loop
//Interrupt Service Routines

ISR(TIMER1_COMPA_vect) //comparator match
{ digitalWrite(triac_control, 1); //triac on;
TCNT1 = 65536-PULSE; //trigger pulse width = PULSE
}
ISR(TIMER1_OVF_vect) //timer1 overflow
{
digitalWrite(triac_control, 0); //turn off triac gate
TCCR1B = 0x00; //disable timer stop unintended triggers
}

void zero_fun() //zero detect
{if (zero_byte)
{ TCCR1B=0x03; //start timer with divide by 64 input
TCNT1 = 0; //reset timer - count from zero
}
}

void rpm_fun()
{
rpmcount++;
//Each rotation, this interrupt function is run
}

 

Спасибо. "ковырялся" и так, и с переводчиком....

Вобщем мозгов у меня не хватило. Даже не до конца понял что куда подключать.  Буду признатеен если пояснишь на "великом и могучем".

Но методом проб и ошибок написл своё.

потенциометр на А0,   Холл на пин 8 ,    Зерро на пин 2,  управление симистором на пин 3.  Дисплей - 4,5,6,7,9,10

Дал 0,5 процента погрешности в каждую сторону от требуемых оборотов.   С 1000 об /мин   держит вполне сносно. Дальше - лучше.   Понимаю, что очень коряво, но довольный как удав.

Пока без всяких "плюшек".  на экран вывел время задержки от нуля,  нужные обороты от потенциометра, паследние показания оборотов датчика и средние обороты.  Хотя средние не очень нравятся. На мой взгляд ошибочны.

#include <LiquidCrystal.h>      // библиотека экрана

LiquidCrystal lcd( 4, 5, 6, 7,9,10);   // пины экрана

int AC_LOAD = 3;    // пин управления симистором

volatile int dimming = 130;  // время задержки от нуля   7 = максимально, 128 = минимально
volatile int i = 0;          // переменная для уменьшения времени задержки.

volatile unsigned long time; // время в микросекундах срабатывания датчика нуля
unsigned long tims;           // переменная показаний времени
       
unsigned long currentTime;     //временные переменные для таймера экрана
unsigned long loopTime;

int obMax = 8000;         //ввести максимальные обороты
int obMin = 200;          //ввести минимальные обороты
float kImp = 12;          //ввести кол-во импульсов на 1 оборот

volatile int holl = 0;    //переменная  срабатываня датчика 
volatile int prOb = 0;   //предвар реальн обороты 
volatile int rOb = 0;    // реальные обороты

volatile int zicls = 0;         // кол-во циклов для средних оборотов.
volatile unsigned long sp = 0;           //переменная суммы оборотов/мин.

volatile unsigned int int_tic;    //переменные для подсчёта времени между импульсами.
volatile unsigned long tic;


void setup()
{
  pinMode(AC_LOAD, OUTPUT);        // назначаем выходом
  attachInterrupt(0, zero_crosss_int, RISING);  // прерывание по пину 2
   
  lcd.begin(16, 2);          //дисплей 16символов 2строчки
  lcd.setCursor(0,0);

lcd.write("R:");  //в верхней строке выводим время задержки

lcd.setCursor(0,1);  

lcd.write("t:");  // В нижней выводим показания датчика

 lcd.setCursor(7,0);

lcd.write("S:");  //в верхней строке будем выводить требуемые обороты

lcd.setCursor(7,1);  

lcd.write("S:");  // В нижней выводим фактичесские обороты

pinMode (8,INPUT); // вход сигнала ICP( №8 only для atmega328)
//настройка 16 бит таймера-счётчика 1 
TCCR1B = 0; TCCR1A = 0; TCNT1 = 0;
TIMSK1 = (1<<ICIE1)|(1<<TOIE1);//создавать прерывание от сигнала на пине ICP1
TCCR1B = (1<<ICNC1)|(1<<ICES1)|(1<<CS10);//div 1
}

ISR (TIMER1_CAPT_vect) { //прерывание захвата сигнала на входе ICP1
tic= ((uint32_t)int_tic<<16)|TCNT1 ; //подсчёт тиков
ICR1=0; int_tic=0; TCNT1=0;
holl =holl+ 1;}   // после каждого срабатывания датчика холл+1

ISR (TIMER1_OVF_vect) { //прерывание для счёта по переполнению uint
int_tic++; //считать переполнения через 65536 тактов
if (int_tic > 50) {tic=0; int_tic=0;} //если на входе пусто более 1/5 секунды
}                                                 //то обнулить счётчики

// the interrupt function must take no parameters and return nothing
void zero_crosss_int()  // function to be fired at the zero crossing to dim the light
{
  time = micros();
  
}

void loop()  {

  
 int val = analogRead(A0);
 int pR =map(val, 0, 1023, obMin, obMax); //Приводим показания регулятора к минимальным и максимальным оборотам
 
         prOb = 60000000/((tic * 0.0625 )*kImp);  //Высчитываем обороты по показаниям датчика
         if( prOb >= 0){             //проверяем на соответствие.       
           rOb = prOb ;              //если нормально, записываем в переменную
          
         }
         else {}
if (val > 0){                  //   если регулятор больше 0 
  if ( holl>=1){               // если сработал датчик
    
     
          if ( rOb < ( pR-pR/200)){  //если реальные обороты меньше нужных - 0,5%
            i= pR / rOb*3 ;          // просчитываем на сколько увеличим управление симистором.
          i = constrain(i,1,5) ;     // ограничиваем результат от 1 до 5
          dimming = dimming-i ;   //меняем время задержки на полученное значение 
                holl = 0;         // обнуляем срабатывание датчика
             }
          else {}
          
         if ( rOb >  ( pR+pR/200)){  //если реальные обороты больше нужнх + 0,5%
          
          dimming =dimming+10 ;   //  время задержки увеличиваем на 10
          dimming = constrain(dimming,7,110) ;  // и ограничиваем от 7 до 110
                holl = 0;     //  обнуляем срабатывание датчика.
             }
          else {}
         }
          else {}
          
       if (tic ==0){              // если двигатель не вращается
           dimming = 100 ; //  время задержки = 100 подбираем опытным путём
           }
        else {}
        
       }
    else {
       dimming =130;      //Если регулятор на 0 то время задержки 130
      }
     
    dimming = constrain(dimming,7,130) ; //  Следим чтоб время задержки было не меньше 7 и не больше 130
    int dimtime = (75*dimming);    // For 60Hz =>65    
    tims = micros();                           // считываем время, прошедшее с момента запуска программы
  if(tims >= (time + dimtime)){       //если время больше или равно времени срабатывания нуля + время задержки
  
  digitalWrite(AC_LOAD, HIGH);   // открываем симистор
  delayMicroseconds(10);         // задержка 10 микросекунд (для 60Hz = 8.33)
  digitalWrite(AC_LOAD, LOW);    // выключаем сигнал на симистор.
  }
  else {}

    sp = sp + rOb;  //суммируем обороты для средних показаний
    zicls = zicls + 1 ;     //считаем кол -во циклов
    
    
      // Для вывода значений на дисплей 1 раз в секунду
      
   currentTime = millis();                           // считываем время, прошедшее с момента запуска программы
  if(currentTime >= (loopTime + 1000)){              // сравниваем текущий таймер с переменной loopTime + 1 секунда
    
    lcd.setCursor(2,1);
    lcd.print(prOb);   
    lcd.print("  ");     // выводим показания датчика
    
    lcd.setCursor(2,0);
    lcd.print(dimming);
    lcd.print("  ");     // выводим время задержки на экран.

    lcd.setCursor(9,0);
    lcd.print(pR);
    lcd.print("       ");     // выводим нужные обороты на экран.
    
     lcd.setCursor(9,1);
    
lcd.print (sp/zicls);      // выводим средние обороты на экран.
lcd.print("       "); 


sp = 0;           //обнуляем переменная суммы оборотов/мин.
zicls = 0;        // обнуляем количество циклов.
    loopTime = currentTime;                         // в loopTime записываем новое значение
  }
}

 

Посмотрите пожалуйста кто знает: http://www.mopedist.ru/blogs/raznye-poleznjashki/upravlenie-kolektornym-dvigatelem-u2010b.html

Правильно я понимаю что эта схема только для коллекторных двигателей работающих от АС напряжения или можно сделать и для ДС?

Вот тут уже реализованный проект на ардуине с пид регулятором  http://bascom.at.ua/publ/simistornyj_pid_reguljator/1-1-0-128

Снова приветствую всех участников темы, и всех с наступающими праздниками.

Появилось свободное врямя, и я снова вернулся к регулятору. Но что то у меня, впрочем как всегда, не идёт.

Решил подойти к вопросу с другой стороны.  Алгоритм такой: Есть нужные нам обороты, например 1000об\мин.  даём "зазор" например 5% в одну и в другую сторону. поручается  от 950 до 1050 об\мин.  Этот промежуток приравниваем к управлению симистором. 950 и ниже - полностью открыт, 1050 и выше - закрыт. Всё что в середине это промежуточные значения.  При таком алгоритме обороты должны стабилизироваться в этом диапазоне в зависимости от нагрузки.

Реализация , на мой взгляд, должна быть такая:

 float ko = pR/rOb;  //делим нужные нам обороты на реальные это коэфициент. если обороты равны, получаем 1, если реальные больше, то от 0 до 1. если меньше то от 1 и выше.  Нас интересует число с 4 цифры после запятой.
    long ai = ko * 10000;  //приводим коэфициент к целому положительному числу.
     int g =map(ai, 10500, 9500, 7, 130);  //задаём значение симистора от7-открыт до 130-закрыт   исходя из полученного числа.

Кажется, всё просто. но почему то не работает. Тоесть работает, но только без промежуточных значений. ВКЛ или ВЫКЛ.  Ошибка в самой первой строке. выводил значения на экран, либо 1, либо 0.  После запятой 00 и всё.  

Что не правильно?

Скорее всего pR и rOb являются целочисленными. В такой ситуации компилятор будет отдавать тоже целочисленные. Для перехода на дроби там нужно каккой-то толи префикс, то ли в конце что-то добавить. Еще не настолько хорошо знаю С.

Спасибо. Но я уже сумел всё исправить и записал всё одной строкой.:

int g =map(rOb, pR*0.95, pR*1.05, ogr, 130);

Если обороты больше 1000, работает хорошо. А меньше - плохо. 

И рывки какието посторонние.

Здесь все зависит от дискретности датчика. Если у вас один такт на оборот (один датчик в месте по кругу вращения), то обратная связь может сильно запаздывать. Для более плавной регулировки на низких оборотах придется увеличить число датчиков для увеличения числа отсчетов. Бесконечно понижать число оборотов все равно не получится и думаю примерно на 400-500 оборотах в минуту наступит предел для понижения уже из-за импульсов ускорения и понижения мощности.

На один оборот приходится 12 импульсов. Уже не так мало. 400-500 об\мин. меня бы устроило.

Обороты считаются на каждом импульсе или усредненно по нескольким?

И еще можно при оборотах скажем ниже 1500 подавать не полный импульс на разгон, а половинный (по ШИМ например) чтобы не было резкого скачка ускорения.

Обороты считаем на каждом импульсе.

Симистор ограничен исходя из оборотов.

Тоже интересна данная тема.

Есть шпиндель 300w 48В, ШИМ регулятор как на фото и инфракрасный датчик.

Разница наверное только в управлении скоростью по шим от 0 до 255.
Пока тестировал все процессы отдельно, все работает. Правда шпиндель через этот регулятор сильно свистит на неполных оборотах. 

P.s.: проблему свиста решил увеличением штатной частоты ШИМ ардуины

Здравствуйте Александр, мне лень заходить на ютуб, поэтому напишу сюда.

Как-то приходилось ремонтировать центрифугу на старой работе, когда работал медтехником, там был тоже коллекторник на 220В, и рулил им мосфет, в целом аппарат был неплох, и работал долго, а попал он к нам, в мастерскую потому, что на датчике Холла окислом убился контакт...  Я это к чему, почему бы Вам не смотреть в сторону высоковольтного полевика и ШИМ? Это же занимает куда меньше ресурсов чем постоянно ждать переход через ноль и ещё добавлять задержку после него?

К стати, мой проект от части пересекается, на данный момент, с Вашим, но у меня не индуктивная нагрузка, пока что, но в планах есть замахнуться и на неё, просто пока что нету RC снабера, а от индуктивной нагрузки, в моём случае, симистор хаотично открывается когда надо и не надо.

P.S. Можно ускорить АЦП, пример тут https://geektimes.ru/post/255744/ тем самым поднять немного общую производительность.
P.P.S. Ешё можно не использовать много раз функцию lcd.print а формировать вывод при помощи sprintf_P http://arduino.ru/forum/programmirovanie/vyvod-na-lcd-teksta-i-dannykh-v-odnoi-stroke#comment-62647

Если почитаете тему с первой страницы, то именно так я и начинал.  Но мои полевики, почему то вылетали один за одним. Может нужен был более мощный, а может нужно было делать драйвер на управление. Незнаю. ответ я так и не нашел. Именно поэтому и перешел на симистор.

В общем, проблема в самом алгоритме стабилизации. Сейчас пробую разные варианты. Удалось снизить порог до 500об.мин.

За советы спасибо.  Буду пробовать.

Вот, мне нравится эта схемотехника:

(с) http://arduino.ru/forum/apparatnye-voprosy/upravlenie-tokarnym-stankom#comment-30941

Только главное частоту ШИМ не задерать выше 1к Гц, оптотрон может несправляться и полевику мало непокажется. Вообще в идеале 50-100 Гц.

И к стати, у меня есть в мыслях возложить на отдельный контроллер фазовое управление, я ему буду только по юарт или АЦП подкидывать нужное значение 0-100%, а основной микроконтроллер будет делать всю остальную работу. 

Схема примерно эта и была, только без опторазвязки.

 

Думаю, это лишнее. И одна ардуинка справляется. 

Просто управлять симистором мы можем 100 раз в секунду,  а импульсов от датчика получаем на 200об\мин получаем всего 40

Опторазвязка нужна, а вдруг что-то пойдёт не так и на затвор полевика пойдёт сетевое напряжение?

Если у Вас была похожая схемотехника странно что полевики вылетали, у центрифуги была похожая схемотехника, там на валу ещё был барабан для пробирок, за счёт этого двигатель останавливался около 20 секунд, и ничего, всё работало. Частоту ШИМ не изменяли? По умолчанию она довольно таки большая, оптотрон может не успевать на ней.

Частоту уменьшал. Вылетали при малейшей нагрузке на вал. Либо если разгон не плавный. Может слабый мосфет стоял? 10А

Согласен, это быстрое решение, мне просто лень переписывать код на Си.

Вы же в курсе что ВВ полевику надо около 9-ти вольт на затвор чтобы тот полностью, а не частично, открывался?

Выбирал цифровой, чтоб 5 вольт на управлении.   10nk60zfp

Да, симмистор получается самый простой вариант, но ведь двигатель это индуктивная нагрузка, от неё симмистору будет не очень хорошо.

  Берёт меня большое сомнение, что от пяти вольт, напрямую, можно управлять сколь нибудь заметной мощностью. Не припомню схем (блоков питания, например), где напряжение управления менее 12 В + драйвер по затвору. Не зря это, не зря.

Полностью с Вами солидарен, драйвер для полевика, особенно высоковольтного нужен 100% при варинте с ШИМ.
Мне кажется что надо юзать IRFP450 + IR2110 для таких целей как у Александра.

А вот и то, о чём я говорил I2C диммер на базе ATtiny85
http://arduino.ru/forum/programmirovanie/attiny85-i-preryvanie#comment-2...

Вот некоторый результат на ПИД-регуляторе. может кто подскажет как правильно подобрать коэффициенты.

https://youtu.be/kf4bfDD_nDc

Похоже вот так выглядит правильная регулировка при помощи ШИМ.

Эта схема практически ничем не отличается от той что вы привели несколькими постами выше. Добавлен только драйвер полевика и запитывается низковольтная часть от стабилитрона вместо батарейки. У меня по такой же схеме собрано, там обратной связью и не пахнет, на низких оборотах момента нету.

ОС можно прикрутить от таходатчика, а регулировку можно сделать плавнее, увеличив разрядность ШИМ, благо ардуина позволяет до целых 10 бит поднять, а это уже, внимание, 0..1023.

И к тому же освободится немного ресурсов, вообщем ШИМ наше всё.

При малых ШИМ никакое повышение его разрядности не добавить момента в мотор. Потому как ШИМ на моторе "интегрируется" и малые значения = малое напряжение на моторе => малый момент мотора. Нужна положительная обратная связь по току и аппаратная, а не "Ардуино".

Есть библия по следящим электроприводам, она правда по аналоговым, но формульная часть присутствует везде

Проблема не в " добавить момента" проблема в точности управления моментом при малых оборотах. И именно разрядность ШИМ тут ключевое. Другой вопрос, что значением ШИМ надо управлять грамотно, т.к. при одном и том же значении ШИМ возможно как медленое движение так и останов. Все потому, что момент трения покоя выше чем момент трения медленого движения. И тахометр, или аналогичное, как раз наилучшее решение проблемы.

 

 

Это вобще нечто трансцендентное. Аппаратную ПОС(!!!) по току должны паять девственицы из бескислородной меди соблюдая направленость проводов.

ПС. Ликбез для использующих слово "момент". В установившемся режиме, т.е. при постоянном числе оборотов (в т.ч и равном 0) момент вращения равен моменту нагрузки. Это 3-ё закон Нютона для вращательного движения. Повышение момента вращения при постоянной нагрузке приводит к повышению числа оборотов и обратно. Момент нагрузки - штука тонкая, зависит от характера нагрузки. Для тележек момента трения покоя при 0 выше чем при малой скорости. Исходя из вышесказаного фразы типа "на низких оборотах момента нету" некоректны.

Задачу стабилизации числа оборотов при неизвестной и переменной нагрузке можно решить только через ОС от числа оборотов (тахометра и т.п.) Стабилизация по току возможна только в узком диапазоне и исключая малые скорости, т.к. ток неоднозначно зависит от частоты.

В аналоговых использовался тахометр )))

Господа, о чем Вы?! Что за диспут аналоговый или цифровой на ардуине? При правильной реализации и одинаковой матмодели существенных различий нет. Про тахометр, так выше уже писано, нужен.

Решил поиграться с коллекторным двигателем, замутил на STM32F103 ШИМ в 20 кГц, слепил такую схемку, по классике жанра - из того что было под рукой, а полевиков логического уровня не было, тем более драйвера для обычных мосфетов, я же не буржуй, поэтому взял, старый добрый TIP122, выпаяный непомню откуда, непомню когда. Транзюк в целом неплох, фронты на входе конечно поровнее чем на выходе, но в целом справляется со своей задачей, тем более ток у меня небольшой, 0.1-0.2А, так как я замутил плавный пуск двигателя, типа этого, только транзюк не КТ827 а TIPок.

Тыкнул осциллом, и тут я кажется понял почему у Александра вылетали высоковольтные полевики - при напряжении питания в 36 В выбросы противоЭДС от движка, и диод HER302 уже не помогает, ничего удивительного, частота то большая.

Как можно увидеть на скрине осцилла, выбросы противоЭДС составляют почти в 2 раза больше напряжение, чем питалово, поэтому надо брать детали, с троекратным запасом.

З.Ы. Пробовал ещё ставить в разрыв по плюсу дроссель на 50 мкГ, испульсы противоЭДС пропадают, добавить кондюк, диод и будет DC-DCшка почти готовая.

а диодом коллектор-эмиттер выходного зашунтировать не пробовали? (как в составном)

Я бы для начала подкинул резистор порядка дестка ом последовотально диоду (он похоже действительно не работает) для снижения добротности контура, дающего колебания. Он кстати судя по частоте на индуктивности потока рассеянья.

Возможно проблема в том, что компоненты у меня все БУ, но я проверил диод мультиметром, он адекватно "звониться".

А зачем? Составной транзистор же имеет.

sany_sch я Вам очень рекомендовал бы отказаться от симмисторного управления в пользу ШИМ, регулировка симмистором это всего лишь диапазон от 7 до 130, а ШИМ можно 0..1023, к тому же освободиться больше ресурсов микроконтроллера, потому как ШИМ аппаратный, минимум математики.

Главное разобраться почему у Вас вылетали транзисторы.

https://www.youtube.com/watch?v=MuyDereKrp8

Он я у себя в группе даже опрос сделал по этому поводу. Большинство согласны что ШИМ лучше.

Здравствуйте. Заинтересовала данная тема по симисторному управлению. Вот только проблемма, у мен ардуино мега 2560 а прошивка заточена под мини, не могли бы вы помочь переделать ее под мегу. Вот код.Заранее спасибо)

int obMin = 200;          //ввести минимальные обороты
int obMax = 9000;         //ввести максимальные обороты
int kImp = 120;          //ввести кол-во импульсов на 10 оборотов
int minzn = 115;           //  минимальное значение симмистора на котором начинается вращение.
int ogrmin =  70 ;         // ограничение симистора на минимальных оборотах.
int mindimming = 80;        //значение симистора при закллинившем станке (первоначальный импульс)
int dopusk =  200 ;         //допуск оборотов в минус и плюс
int razgon = 50;            //переменная разгона 1 - 100


#include <LiquidCrystal.h>      // библиотека экрана

LiquidCrystal lcd( 9, 10, 4, 5, 6, 7); // пины экрана

int AC_LOAD = 3;    // пин управления симистором
volatile int dimming = 130;  // время задержки от нуля   7 = максимально, 130 = минимально
volatile unsigned long time; // время в микросекундах срабатывания датчика нуля
unsigned long tims;           // переменная показаний времени

unsigned long currentTime;     //временные переменные для таймера экрана
unsigned long loopTime;

int holl = 0;    //переменная  срабатываня датчика
int pR;                  // показания регулятора
int pRR;                // переменная для расчёта.
int ogr ;                 //переменная ограничений симистора натекущих оборотах
volatile int sp = 0;           //переменная суммы срабатываний датчика
volatile int prOb ;   //предвар реальн обороты
volatile int rOb ;    // реальные обороты

volatile unsigned int int_tic;    //переменные для подсчёта времени между импульсами.
volatile unsigned long tic;
volatile int t = 0;               //минимальное время импульсов +1
int val ;
void setup()
{
  pRR = obMin;
  t = (15000 / ( obMin * (kImp / 10))) * 2; //высчитываем минимальное время импульсов +1
  pinMode(AC_LOAD, OUTPUT);        // назначаем выходом
  attachInterrupt(0, zero_crosss_int, RISING);  // прерывание по пину 2

  lcd.begin(16, 2);          //дисплей 16символов 2строчки
  lcd.setCursor(0, 0);

  lcd.write("R:");  //в верхней строке выводим время задержки

  lcd.setCursor(0, 1);

  lcd.write("t:");  // В нижней выводим показания датчика

  lcd.setCursor(8, 0);

  lcd.write("S:");  //в верхней строке будем выводить требуемые обороты

  lcd.setCursor(8, 1);

  lcd.write("S:");  // В нижней выводим фактичесские обороты


  pinMode (8, INPUT); // вход сигнала ICP( №8 only для atmega328)
  //настройка 16 бит таймера-счётчика 1
  TCCR1B = 0; TCCR1A = 0; TCNT1 = 0;
  TIMSK1 = (1 << ICIE1) | (1 << TOIE1); //создавать прерывание от сигнала на пине ICP1
  TCCR1B = (1 << ICNC1) | (1 << ICES1) | (1 << CS10); //div 1

}

ISR (TIMER1_CAPT_vect) { //прерывание захвата сигнала на входе ICP1
  tic = ((uint32_t)int_tic << 16) | ICR1 ; //подсчёт тиков
  ICR1 = 0; int_tic = 0; TCNT1 = 0;
  sp = sp + 1 ; // для подсчёта оборотов в минуту.
  holl = holl + 1;
}   // после каждого срабатывания датчика холл+1


ISR (TIMER1_OVF_vect) { //прерывание для счёта по переполнению uint
  int_tic++; //считать переполнения через 65536 тактов
  if (int_tic > t) {
    tic = 0;  //если на входе пусто более минимального времени то обнулить счётчики
    int_tic = 0;
  }
  if (int_tic > 500) {
    dimming = 130; // если стоим 2 секунды, то сбрасываем напряжение.
  }
}

// the interrupt function must take no parameters and return nothing
void zero_crosss_int()  // function to be fired at the zero crossing to dim the light
{
  time = micros();

}

void loop()  {


  val = analogRead(A0);
  pR = map(val, 0, 1023, obMin, obMax); //Приводим показания регулятора к минимальным и максимальным оборотам

  if (val > 0) {                                       //   если регулятор больше 0
    if ( holl >= 1) {                                  // если сработал датчик
      prOb = 60000000 / ((tic * 0.0625 ) * kImp / 10); //Высчитываем обороты по показаниям датчика
      if ( prOb >= 0) {                                //проверяем на соответствие.
        rOb = prOb ;                                   //если нормально, записываем в реальные обороты

      }
      if ( rOb < pR ) {                                //сверяем показания регулятора и реальные обороты
        int fff = pR  - rOb;                           //узнаём разницу между оборотами
        int pRu = map(fff, 1, obMax, 1, razgon);       //исходя из разницы и разгона высчитываем на сколько увеличить переменную для расчёта
        pRR = pRR + pRu  ;                             //увеличиваем переменную расчёта
      }
      if ( pR < (rOb - 20) ) {                         //сверяем показания регулятора и реальные обороты
        int fff = rOb - 20  - pR;                      //узнаём разницу между оборотами
        int pRu = map(fff, 1, obMax, 1, razgon);       //исходя из разницы и разгона высчитываем на сколько уменьшить переменную для расчёта
        pRR = pRR - pRu ;                              //увеличиваем переменную расчёта
      }
      pRR = constrain(pRR, (pR / 2), obMax);           //задаём пределы переменной для расчёта.
      ogr = map(val, 0, 1023, ogrmin, 7);              //исходя из показаний регулятора узнаём на сколько может быть открыт симистор.
      
      dimming = map(rOb, (pRR - dopusk), (pRR + dopusk), ogr, minzn); //рассчитываем управление симистором.
      holl = 0;                                                       // обнуляем срабатывание датчика
    }
    
    if (tic == 0) {                                    // если двигатель не вращается
      dimming = mindimming ;                          //  время задержки равно первоначальному импульсу
    }
    dimming = constrain(dimming, ogr, minzn) ;       //  Следим чтоб время задержки было не меньше ограничения и не больше минимального значения
  }
  else {
    dimming = 130;                                   //Если регулятор на 0 то время задержки 130
    pRR = obMin;
  }


  int dimtime = (75 * dimming);               // For 60Hz =>65
  tims = micros();                            // считываем время, прошедшее с момента запуска программы
  if (tims >= (time + dimtime)) {             //если время больше или равно времени срабатывания нуля + время задержки

    digitalWrite(AC_LOAD, HIGH);              // открываем симистор
    delayMicroseconds(10);                   // задержка 10 микросекунд (для 60Hz = 8.33)
    digitalWrite(AC_LOAD, LOW);              // выключаем сигнал на симистор.
  }
  else {}




  // Для вывода значений на дисплей 2 раз в секунду

  currentTime = millis();                           // считываем время, прошедшее с момента запуска программы
  if (currentTime >= (loopTime + 500)) {            // сравниваем текущий таймер с переменной loopTime + 0,5 секунд

    // выводим показания датчика

    lcd.setCursor(2, 0);
    lcd.print(dimming );
    lcd.print("  ");     // выводим время задержки на экран.

    lcd.setCursor(2, 1);
    lcd.print(val );
    lcd.print("  ");     // выводим нужные обороты на экран.

    lcd.setCursor(10, 0);
    lcd.print(map(val, 0, 1023, obMin, obMax));
    lcd.print("       ");     // выводим нужные обороты на экран.

    lcd.setCursor(10, 1);

    lcd.print (sp * (1200 / kImp)); // выводим средние обороты на экран.
    lcd.print("       ");
    sp = 0;
    loopTime = currentTime;                         // в loopTime записываем новое значение
  }
}

 

Ладно попробую начать сам .Я так понимаю что основная проблемма это отсутствие у меги вывода модуля захата ICP1, остальные пины вроде как соответствуют пинам ардуины мини. Как можно реализовать эту функцию в меге??? Хочу сказать сразу что в програмировании я не сильно силен, но стремление огромное)