плавный пуск + регулятор скорости коллекторного двигателя

[Serrad]

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

[Dimon456]

Это схема детектора перехода через ноль с бп, симистор к ней как-то рано.

Там же еще МК будет? Или полностью схему нарисовать?

Управляющий ток, если его действительно не хватает, обеспечивают транзистором. Зачем сразу лепить оптрон?

С чего вы будете брать питание для этого транзистора?
U2010B выдает 125 мА, это более чем достаточно для открытия любого симистора.
Понадобится высоковольтный транзистор и ...., напомните мне чем симистор отличается от тиристора?

MOC3023 - это готовое решение, с минимумом обвеса.

Мое мнение остается неизменным - существует специализированная микросхема фазового управления с обратной связью по току и защитой от перегрузки U2010B. Остальное "велосипед".

Но если все таки "велосипед", то сначала я бы собрал источник питания, нагрузил бы его нагрузкой 100 - 150 мА, светодиод поставил бы для визуального контроля, и раз так 50 включить-выключить, если не увидим "зарождение электрона", то все ОК.
Тут же прибором контролируем наличие 5 Вольт, осциллографом проверяем схему детектора, возможно так же применение стабилизатора AMS1117. (?)
PS на схеме не дорисовал один резистор килоом так на 300 параллельно С1.

[musor]

таких микрух хватает
U2010B. лиш 1из них и не самая распространеная
у нас например в рознице не наблюдаю сейчас

[BlackKilkennyCat]

[uquote="Dimon456",url="/forum/viewtopic.php?p=3899656#p3899656"]Там же еще МК будет? Или полностью схему нарисовать?[/uquote]
Вообще-то да. Какой смысл от очередного варианта бестрансформаторного питания и чем оно отличается от ранее описанных?

С чего вы будете брать питание для этого транзистора?
U2010B выдает 125 мА, это более чем достаточно для открытия любого симистора.

а она эти 125 мА где берет?

Понадобится высоковольтный транзистор

нет

и ...., напомните мне чем симистор отличается от тиристора?

поясните, что имеете в виду, без намеков.

MOC3023 - это готовое решение, с минимумом обвеса.

дорого и много места. Кроме того, надо быть последовательным - какой смысл готовое решение в одном лишь месте? Давайте и всё остальное в виде готового решения, они есть.

существует специализированная микросхема фазового управления с обратной связью по току и защитой от перегрузки U2010B. Остальное "велосипед".

Велосипеды изобретают до сих пор. Ваш вариант блока питания с детектором нуля - тот же велосипед, как и 99% радиолюбительских поделок в сегодняшнее время, к чему об этом разговаривать? Кроме того, существует куча различных требований к режимам работы электроприводов, и не всегда какая-то уникально-заточенная микросхема может их обеспечить. И как заметил musor, микросхема редкая, а вариант покупать на али - да лучше выкинуть электропривод и пойти пить чай...

[Dimon456]

Давайте и всё остальное в виде готового решения, они есть.

U2010B

[BlackKilkennyCat]

ну, вот так лучше

[Serzh2000]

во че нашел!

фьюзы: Low = 0x2A , High = 0xFB

Добавлено after 5 hours 53 minutes 43 seconds:
Re: плавный пуск + регулятор скорости коллекторного двигателя
допишите плавный пуск, кому не трудно у меня не получается

Спойлер

#define F_CPU (9600000uL /

#include "stdint.h"
#include "avr/io.h"
#include "avr/interrupt.h"
#include "util/delay.h"


#define PWM_AC_PULSE 4
#define PWM_MIN 5
#define PWM_MAX_DIF 10

#define LIMIT_INC 10

#define STARTUP_DELAY 50

#define KBD_ADC_THRESHOLD 5
#define KBD_CNT_ONOFF 5
#define KBD_CNT_ONOFF_THRESHOLD 50
#define KBD_CNT_LONG 200


inline void pwm2_on() { PORTB |= (1<<PB1); }
inline void pwm2_off(){ PORTB &= ~(1<<PB1); }




volatile uint8_t sync_flag; // PWM top sync flag

volatile uint8_t pwm_top=0xFF; // PWMs maximum
register uint8_t pwm_set[2] asm("r2"); // PWMS set
register uint8_t pwm_cur[2] asm("r4"); // PWMS current
register uint8_t pwm_ac asm("r6"); // AC sync flag

uint8_t limit_en[2] = {1,1},limit[2];

uint8_t startup_cnt = STARTUP_DELAY;

uint8_t kbd_en[2], kbd_cnt[2], kbd_prev[2],kbd_cur[2], kbd_inc[2];



int main(){
// setup

// GPIO
PORTB |= (1<<PB3)|(1<<PB2);
DDRB &= ~((1<<PB2)|(1<<PB3));
PORTB &= ~(1<<PB1);
DDRB |= (1<<PB1);

// PCINT
GIMSK |= (1<<PCIE);
PCMSK = (1<<PCINT2);

// timer 0
TCCR0A = 0;
TCCR0B = (1<<CS01)|(1<<CS00);
TIMSK0 = (1<<TOIE0)|(1<<OCIE0B)|(1<<OCIE0A);

// ADC
ADMUX = (1<<ADLAR)|(1<<MUX1);
ADCSRA = (1<<ADEN)|(1<<ADSC)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);
ADCSRB = 0;
DIDR0 = 0;




pwm_set[0] = pwm_set[1] = 0xFF;


sei();

// main loop
while(1){
// ZC sync
if (sync_flag){
sync_flag = 0;

// decrement startup timer
if (startup_cnt) startup_cnt--;

// update limiters
else for (uint8_t i=0; i<2; i++){
if (limit_en == 1){ // limit increment
if (limit < (0xFF - LIMIT_INC)) limit += LIMIT_INC;
else {
limit = 0xFF;
limit_en = 0;
}
} else if (limit_en == 2){ // limit decrement
if (limit > LIMIT_INC) limit -= LIMIT_INC;
else {
limit = 0;
limit_en = 0;
}
}
}

// calculate PWMs
uint8_t pwm = (!pwm_set[0]) ? 0 : (pwm_set[0] < limit[0]) ? pwm_set[0] : limit[0];
pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> ;
pwm_cur[0] = (startup_cnt || (pwm_set[0] < PWM_MIN)||((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;

pwm = (!pwm_set[1]) ? 0 : (pwm_set[1] < limit[1]) ? pwm_set[1] : limit[1];
pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> ;
pwm_cur[1] = (startup_cnt || (pwm_set[1] < PWM_MIN)||((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;

// read ADC
if (ADMUX & (1<<MUX0)){ ADMUX &= ~(1<<MUX0); if (!kbd_en[1]) pwm_set[1] = ADCH;
} else { ADMUX |= (1<<MUX0); if (!kbd_en[0]) pwm_set[0] = ADCH; }
ADCSRA |= (1<<ADSC);



}
}

// exit
return 0;
}



ISR(TIM0_COMPB_vect){
if (pwm_cur[1]){
pwm2_on();
sei();
if (pwm_ac){
_delay_us(PWM_AC_PULSE);
pwm2_off();
}
}
}

ISR(TIM0_OVF_vect){
pwm2_off(); // PWMs off
pwm_top = 0xFF; // update PWM top
OCR0A = pwm_cur[0]; OCR0B = pwm_cur[1]; // reload PWMs
sync_flag = 1; pwm_ac = 0; // set Sync flag / reset AC flag
TIFR0 |= (1<<OCF0A)|(1<<OCF0B); // reset capture interrupts
}

// external interrupt on zero-cross
ISR(PCINT0_vect){
pwm2_off(); // PWMs off
pwm_top = TCNT0; // get PWM top
// uint8_t cnt = TCNT0; // get PWM top
TCNT0 = 0; // reset TCNT0
OCR0A = pwm_cur[0]; OCR0B = pwm_cur[1]; // reload PWMs
sync_flag = pwm_ac = 1; // set Sync/AC flag
// pwm_top = ((uint16_t)cnt + pwm_top) >> 1; // filter PWM top
TIFR0 |= (1<<OCF0A)|(1<<OCF0B)|(1<<TOV0); // reset capture interrupts
}

[Serzh2000]

Спойлер

#define F_CPU (9600000uL / 8 )

#include "stdint.h"
#include "avr/io.h"
#include "avr/interrupt.h"
#include "util/delay.h"


#define PWM_AC_PULSE 4
#define PWM_MIN 5
#define PWM_MAX_DIF 10

#define LIMIT_INC 10 //ПРЕДЕЛ

#define STARTUP_DELAY 50 //ЗАДЕРЖКА ЗАПУСКА

#define KBD_ADC_THRESHOLD 5 //ПОРОГ АЦП



inline void pwm2_on() { PORTB |= (1<<PB1); }
inline void pwm2_off(){ PORTB &= ~(1<<PB1); }




volatile uint8_t sync_flag; //Флаг верхней синхронизации ШИМ
volatile uint8_t pwm_top=0xFF; // Максимальное ШИМ
register uint8_t pwm_set[2] asm("r2"); // ШИМ-комплект
register uint8_t pwm_cur asm("r4"); // Ток ШИМ
register uint8_t pwm_ac asm("r6"); // Флаг синхронизации переменного тока

unsigned int start_first = 0; // флаг первого запуска

uint8_t limit_en[2] = {1,1},limit[2];

uint8_t startup_cnt = STARTUP_DELAY;

uint8_t kbd_en[2]; //kbd_inc[2];



int main(){
// setup

// GPIO
PORTB |= (1<<PB3)|(1<<PB2);
DDRB &= ~((1<<PB2)|(1<<PB3));
PORTB &= ~(1<<PB1);
DDRB |= (1<<PB1);

// PCINT
GIMSK |= (1<<PCIE);
PCMSK = (1<<PCINT2);

// timer 0
TCCR0A = 0;
TCCR0B = (1<<CS01)|(1<<CS00);
TIMSK0 = (1<<TOIE0)|(1<<OCIE0B)|(1<<OCIE0A);

// ADC
ADMUX = (1<<ADLAR)|(1<<MUX1);
ADCSRA = (1<<ADEN)|(1<<ADSC)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);
ADCSRB = 0;
DIDR0 = 0;

sei();

// main loop
while(1){




// ZC sync
if (sync_flag){
sync_flag = 0;

//===плавный старт======================
if (start_first==0){
for (pwm_cur = 0; pwm_cur < 0xFF; pwm_cur++){

for (int k = 0; k<10000; k++){ // ПОТОМ УБРАТЬ !!!

if (!kbd_en[1]) pwm_set[1] = ADCH;

if (!kbd_en[0]) pwm_set[0] = ADCH;
}
}
start_first = 1;
}
//========

// таймер запуска уменьшение
if (startup_cnt) startup_cnt--;

// ограничители обновления
else for (uint8_t i=0; i<2; i++){
if (limit_en == 1){ // предельное увеличение
if (limit < (0xFF - LIMIT_INC)) limit += LIMIT_INC;
else {
limit = 0xFF;
limit_en = 0;
}
} else if (limit_en == 2){ //предельное уменьшение
if (limit > LIMIT_INC) limit -= LIMIT_INC;
else {
limit = 0;
limit_en = 0;
}
}
}

// расчет ШИМ
uint8_t pwm = (!pwm_set[0]) ? 0 : (pwm_set[0] < limit[0]) ? pwm_set[0] : limit[0];
pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> 8 ) ;


pwm = (!pwm_set[1]) ? 0 : (pwm_set[1] < limit[1]) ? pwm_set[1] : limit[1];
pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> 8 ) ;
pwm_cur = (startup_cnt || (pwm_set[1] < PWM_MIN)||((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;

// read ADC
if (ADMUX & (1<<MUX0)){ ADMUX &= ~(1<<MUX0); if (!kbd_en[1]) pwm_set[1] = ADCH;
} else { ADMUX |= (1<<MUX0); if (!kbd_en[0]) pwm_set[0] = ADCH; }
ADCSRA |= (1<<ADSC);
}
}

// exit
return 0;
}



ISR(TIM0_COMPB_vect){ //внешнее прирывание
if (pwm_cur){
pwm2_on();
sei();
if (pwm_ac){
_delay_us(PWM_AC_PULSE); //ШИМ-ИМПУЛЬС ПЕРЕМЕННОГО ТОКА
pwm2_off();
}
}
}

ISR(TIM0_OVF_vect){
pwm2_off(); // PWMs off
pwm_top = 0xFF; // обновление PWM сверху
OCR0B = pwm_cur; // перезарядка ШИМ
sync_flag = 1; pwm_ac = 0; // установить флаг синхронизации / сбросить флаг переменного тока
TIFR0 |= (1<<OCF0A)|(1<<OCF0B); // сброс прерываний захвата
}

// внешнее прерывание на нулевом пересечении
ISR(PCINT0_vect){
pwm2_off(); // PWMs off
pwm_top = TCNT0; // получить ШИМ сверху
// uint8_t cnt = TCNT0; //получить ШИМ сверху
TCNT0 = 0; // сброс TCNT0
OCR0B = pwm_cur; // перезарядка ШИМ
sync_flag = pwm_ac = 1; // установить флаг синхронизации/переменного тока
// pwm_top = ((uint16_t)cnt + pwm_top) >> 1; // фильтр ШИМ сверху
TIFR0 |= (1<<OCF0A)|(1<<OCF0B)|(1<<TOV0); // сброс прерываний захвата
}

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

for (pwm_cur = 0; pwm_cur < "переменная"на центральном контакте переменного резистора; pwm_cur++)

[oleg110592]

тэг 'Code' есть для исходников - покрасивше будет
переменная вроде эта с ацп считывается

Код: Выделить всё

 pwm_set[0] = ADCH; 

[Serzh2000]

Код: Выделить всё

				//===плавный старт===
					
		             if (start_first==0){
						 //int STOP =ADCH;
							for (pwm_cur = 0xC8; pwm_cur > ADCH; pwm_cur--){

								    for (int k = 0; k<10000; k++){  // ПОТОМ УБРАТЬ !!!
								 
									if (!kbd_en[1]) pwm_set[1] =ADCH;
									
								    if (!kbd_en[0]) pwm_set[0] =ADCH;	
															}
								}
                              start_first = 1;
							}
	         //===================	

НИ ФИГА НЕ ПОЛУЧАЕТСЯ

начинается с 0xC8 правильно, и не останавливаясь на середине примерно 0х7F увеличивает обороты до 0хFF и только потом становиться в нужное положение




порект взят с https://www.radiokot.ru/forum/viewtopic.php?p=2353553 автор ncp1400

[oleg110592]

вообще плавный пуск есть, но коротенький, удлинить наверное можно

повыкидывал "лишнее":
main.c

Спойлер

Код: Выделить всё

/*
 * main.c
 *
 *  Created on: May 11, 2015
 *      Author: qwer
 */

#include "main.h"

volatile uint8_t sync_flag; // PWM top sync flag

volatile uint8_t pwm_top = 0xFF;	   // PWMs maximum
register uint8_t pwm_set[2] asm("r2"); // PWMS set
register uint8_t pwm_cur[2] asm("r4"); // PWMS current
register uint8_t pwm_ac asm("r6");	   // AC sync flag

uint8_t limit_en[2] = {1, 1}, limit[2];

uint8_t startup_cnt = STARTUP_DELAY;

uint8_t kbd_en[2], kbd_cnt[2], kbd_prev[2], kbd_cur[2], kbd_inc[2];

uint8_t pwm_sete[2] EEMEM;
register uint8_t eep_update_cnt asm("r7");

#define pwm2_on() PORTB |= (1 << PB1)
#define pwm2_off() PORTB &= ~(1 << PB1)

int main()
{
	// setup

	// GPIO
	PORTB |= (1 << PB3) | (1 << PB4) | (1 << PB2);
	DDRB &= ~((1 << PB2) | (1 << PB3) | (1 << PB4));
	PORTB &= ~((1 << PB0) | (1 << PB1));
	DDRB |= (1 << PB0) | (1 << PB1);

	// PCINT
	GIMSK |= (1 << PCIE);
	PCMSK = (1 << PCINT2);

	// timer 0
	TCCR0A = 0;
	TCCR0B = (1 << CS01) | (1 << CS00);
	TIMSK0 = (1 << TOIE0) | (1 << OCIE0B) | (1 << OCIE0A);

	// ADC
	ADMUX = (1 << ADLAR) | (1 << MUX1);
	ADMUX |= (1 << MUX0);
	ADCSRA = (1 << ADEN) | (1 << ADSC) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
	ADCSRB = 0;
	DIDR0 = 0;

	// check buttons/Pots
	for (uint8_t i = 0; i < 2; i++)
	{
		while (ADCSRA & (1 << ADSC))
			;
		kbd_en[i] = (ADCH < KBD_ADC_THRESHOLD) || (ADCH > (0xFF - KBD_ADC_THRESHOLD));
		if (kbd_en[i])
			limit_en[i] = 0;
		//ADMUX ^= (1 << MUX0);
		ADCSRA |= (1 << ADSC);
	}

	// restore current power from EEPROM
	//	pwm_set[0] = eeprom_read_byte(&pwm_sete[0]);
	//	pwm_set[1] = eeprom_read_byte(&pwm_sete[1]);
	//	pwm_set[0] = pwm_set[1] = 0xFF;
	EEARL = 0;
	EECR |= (1 << EERE);
	pwm_set[0] = EEDR;
	EEARL = 1;
	EECR |= (1 << EERE);
	pwm_set[1] = EEDR;

	sei();

	// main loop
	while (1)
	{
		// ZC sync
		if (sync_flag)
		{
			sync_flag = 0;

			// decrement startup timer
			if (startup_cnt)
			{
				startup_cnt--;
			}

			// update limiters
			else
			{
				for (uint8_t i = 0; i < 2; i++)
				{
					if (limit_en[i] == 1)
					{ // limit increment
						if (limit[i] < (0xFF - LIMIT_INC))
							limit[i] += LIMIT_INC;
						else
						{
							limit[i] = 0xFF;
							limit_en[i] = 0;
						}
					}
					else if (limit_en[i] == 2)
					{ // limit decrement
						if (limit[i] > LIMIT_INC)
							limit[i] -= LIMIT_INC;
						else
						{
							limit[i] = 0;
							limit_en[i] = 0;
						}
					}
				}
			}
			// calculate PWMs

			uint8_t pwm = (!pwm_set[1]) ? 0 : (pwm_set[1] < limit[1]) ? pwm_set[1] : limit[1];
			pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> 8);
			pwm_cur[1] = (startup_cnt || (pwm_set[1] < PWM_MIN) || ((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;

			// read ADC
			if (ADMUX & (1 << MUX0))
			{
				if (!kbd_en[1])
					pwm_set[1] = ADCH;
			}
			ADCSRA |= (1 << ADSC);
		}
	}

	// exit
	return 0;
}

ISR(TIM0_COMPA_vect)
{
}

ISR(TIM0_COMPB_vect)
{
	if (pwm_cur[1])
	{
		pwm2_on();
		sei();
		if (pwm_ac)
		{
			_delay_us(PWM_AC_PULSE);
			pwm2_off();
		}
	}
}

ISR(TIM0_OVF_vect)
{
	pwm2_off();			// PWMs off
	pwm_top = 0xFF;		// update PWM top
	OCR0B = pwm_cur[1]; // reload PWMs
	sync_flag = 1;
	pwm_ac = 0;							  // set Sync flag / reset AC flag
	TIFR0 |= (1 << OCF0A) | (1 << OCF0B); // reset capture interrupts
}

// external interrupt on zero-cross
ISR(PCINT0_vect)
{
	pwm2_off();											// PWMs off
	pwm_top = TCNT0;									// get PWM top
														//	uint8_t cnt = TCNT0;                      // get PWM top
	TCNT0 = 0;											// reset TCNT0
	OCR0B = pwm_cur[1];									// reload PWMs
	sync_flag = pwm_ac = 1;								// set Sync/AC flag
														//	pwm_top = ((uint16_t)cnt + pwm_top) >> 1; // filter PWM top
	TIFR0 |= (1 << OCF0A) | (1 << OCF0B) | (1 << TOV0); // reset capture interrupts
}

main.h

Спойлер

Код: Выделить всё

/*
 * main.h
 *
 *  Created on: May 11, 2015
 *      Author: qwer
 */

#ifndef MAIN_H_
#define MAIN_H_

#define F_CPU (9600000uL / 8)

#include "stdint.h"
#include "avr/io.h"
#include "avr/interrupt.h"
#include "util/delay.h"
#include "avr/eeprom.h"

#define PWM_AC_PULSE            4
#define PWM_MIN                 5
#define PWM_MAX_DIF             10

#define LIMIT_INC               10

#define STARTUP_DELAY           50

#define KBD_ADC_THRESHOLD       5
#define KBD_CNT_ONOFF           5
#define KBD_CNT_ONOFF_THRESHOLD 50
#define KBD_CNT_LONG            200

#endif /* MAIN_H_ */

[Serzh2000]

вообще плавный пуск есть, но коротенький, удлинить наверное можно

наверно... я только второй день ломаю голову... еще вся жизнь впереди

[oleg110592]

легким движением руки удлиняем в три раза (больше тоже легко - увеличиваем магическую цифру '3' ):

Спойлер

Код: Выделить всё

/*
 * main.c
 *
 *  Created on: May 11, 2015
 *      Author: qwer
 */

#include "main.h"

volatile uint8_t sync_flag; // PWM top sync flag
uint8_t sync_cnt;

volatile uint8_t pwm_top = 0xFF;	   // PWMs maximum
register uint8_t pwm_set[2] asm("r2"); // PWMS set
register uint8_t pwm_cur[2] asm("r4"); // PWMS current
register uint8_t pwm_ac asm("r6");	   // AC sync flag

uint8_t limit_en[2] = {1, 1}, limit[2];

uint8_t startup_cnt = STARTUP_DELAY;

uint8_t kbd_en[2], kbd_cnt[2], kbd_prev[2], kbd_cur[2], kbd_inc[2];

uint8_t pwm_sete[2] EEMEM;
register uint8_t eep_update_cnt asm("r7");

#define pwm2_on() PORTB |= (1 << PB1)
#define pwm2_off() PORTB &= ~(1 << PB1)

int main()
{
	// setup

	// GPIO
	PORTB |= (1 << PB3) | (1 << PB4) | (1 << PB2);
	DDRB &= ~((1 << PB2) | (1 << PB3) | (1 << PB4));
	PORTB &= ~((1 << PB0) | (1 << PB1));
	DDRB |= (1 << PB0) | (1 << PB1);

	// PCINT
	GIMSK |= (1 << PCIE);
	PCMSK = (1 << PCINT2);

	// timer 0
	TCCR0A = 0;
	TCCR0B = (1 << CS01) | (1 << CS00);
	TIMSK0 = (1 << TOIE0) | (1 << OCIE0B) | (1 << OCIE0A);

	// ADC
	ADMUX = (1 << ADLAR) | (1 << MUX1);
	ADMUX |= (1 << MUX0);
	ADCSRA = (1 << ADEN) | (1 << ADSC) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
	ADCSRB = 0;
	DIDR0 = 0;

	// check buttons/Pots
	for (uint8_t i = 0; i < 2; i++)
	{
		while (ADCSRA & (1 << ADSC))
			;
		kbd_en[i] = (ADCH < KBD_ADC_THRESHOLD) || (ADCH > (0xFF - KBD_ADC_THRESHOLD));
		if (kbd_en[i])
			limit_en[i] = 0;
		//ADMUX ^= (1 << MUX0);
		ADCSRA |= (1 << ADSC);
	}

	// restore current power from EEPROM
	//	pwm_set[0] = eeprom_read_byte(&pwm_sete[0]);
	//	pwm_set[1] = eeprom_read_byte(&pwm_sete[1]);
	//	pwm_set[0] = pwm_set[1] = 0xFF;
	EEARL = 0;
	EECR |= (1 << EERE);
	pwm_set[0] = EEDR;
	EEARL = 1;
	EECR |= (1 << EERE);
	pwm_set[1] = EEDR;
	sync_cnt = 0;

	sei();

	// main loop
	while (1)
	{
		// ZC sync
		if (sync_flag)
		{

			sync_flag = 0;
			if (++sync_cnt == 3)
			{
				sync_cnt = 0;
				// decrement startup timer
				if (startup_cnt)
				{
					startup_cnt--;
				}

				// update limiters
				else
				{
					for (uint8_t i = 0; i < 2; i++)
					{
						if (limit_en[i] == 1)
						{ // limit increment
							if (limit[i] < (0xFF - LIMIT_INC))
								limit[i] += LIMIT_INC;
							else
							{
								limit[i] = 0xFF;
								limit_en[i] = 0;
							}
						}
						else if (limit_en[i] == 2)
						{ // limit decrement
							if (limit[i] > LIMIT_INC)
								limit[i] -= LIMIT_INC;
							else
							{
								limit[i] = 0;
								limit_en[i] = 0;
							}
						}
					}
				}
			}
			// calculate PWMs

			uint8_t pwm = (!pwm_set[1]) ? 0 : (pwm_set[1] < limit[1]) ? pwm_set[1] : limit[1];
			pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> 8);
			pwm_cur[1] = (startup_cnt || (pwm_set[1] < PWM_MIN) || ((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;

			// read ADC
			if (ADMUX & (1 << MUX0))
			{
				if (!kbd_en[1])
					pwm_set[1] = ADCH;
			}
			ADCSRA |= (1 << ADSC);
		}
	}

	// exit
	return 0;
}

ISR(TIM0_COMPA_vect)
{
}

ISR(TIM0_COMPB_vect)
{
	if (pwm_cur[1])
	{
		pwm2_on();
		sei();
		if (pwm_ac)
		{
			_delay_us(PWM_AC_PULSE);
			pwm2_off();
		}
	}
}

ISR(TIM0_OVF_vect)
{
	pwm2_off();			// PWMs off
	pwm_top = 0xFF;		// update PWM top
	OCR0B = pwm_cur[1]; // reload PWMs
	sync_flag = 1;
	pwm_ac = 0;							  // set Sync flag / reset AC flag
	TIFR0 |= (1 << OCF0A) | (1 << OCF0B); // reset capture interrupts
}

// external interrupt on zero-cross
ISR(PCINT0_vect)
{
	pwm2_off();											// PWMs off
	pwm_top = TCNT0;									// get PWM top
														//	uint8_t cnt = TCNT0;                      // get PWM top
	TCNT0 = 0;											// reset TCNT0
	OCR0B = pwm_cur[1];									// reload PWMs
	sync_flag = pwm_ac = 1;								// set Sync/AC flag
														//	pwm_top = ((uint16_t)cnt + pwm_top) >> 1; // filter PWM top
	TIFR0 |= (1 << OCF0A) | (1 << OCF0B) | (1 << TOV0); // reset capture interrupts
}

в main.h поменял

Код: Выделить всё

#define STARTUP_DELAY           5

правда и ацп медленнее вычитывается...

[Serzh2000]

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

[oleg110592]

так там еще можно крутить типа

Код: Выделить всё

#define LIMIT_INC               1

[Serzh2000]

#define LIMIT_INC

Я ТАК ПОНЯЛ - ЭТО ШАГИ ПЕРЕМЕННОГО РЕЗИСТОРА ИЛИ НЕТ?

[oleg110592]

не, онj участвует в значении переменной pwm, от которой зависит pwm_cur[1], которое записывают в OCR0B = pwm_cur[1]; // reload PWMs

Код: Выделить всё

uint8_t pwm = (!pwm_set[1]) ? 0 : (pwm_set[1] < limit[1]) ? pwm_set[1] : limit[1];

типа на сколько добавить/убавить значение (самому не до конца понятный механизм)

Код: Выделить всё

// limit increment
	if (limit[i] < (0xFF - LIMIT_INC))
	limit[i] += LIMIT_INC;
 // limit decrement
	if (limit[i] > LIMIT_INC)
	limit[i] -= LIMIT_INC;

[Serzh2000]

Спойлер

#define F_CPU (9600000uL / 8 )

#include "stdint.h"
#include "avr/io.h"
#include "avr/interrupt.h"
#include "util/delay.h"


#define PWM_AC_PULSE 4
#define PWM_MIN 5
#define PWM_MAX_DIF 10

#define LIMIT_INC 10

#define STARTUP_DELAY 50

#define KBD_ADC_THRESHOLD 5
#define KBD_CNT_ONOFF 5
#define KBD_CNT_ONOFF_THRESHOLD 50
#define KBD_CNT_LONG 200


inline void pwm2_on() { PORTB |= (1<<PB1); }
inline void pwm2_off(){ PORTB &= ~(1<<PB1); }

unsigned int start_first = 0;
unsigned int STOP;


volatile uint8_t sync_flag; // PWM top sync flag

volatile uint8_t pwm_top=0xFF; // PWMs maximum
register uint8_t pwm_set asm("r2"); // PWMS set
register uint8_t pwm_cur asm("r4"); // PWMS current
register uint8_t pwm_ac asm("r6"); // AC sync flag

uint8_t limit_en = 1, limit;

uint8_t startup_cnt = STARTUP_DELAY;




int main(){
// setup

// GPIO
PORTB |= (1<<PB3)|(1<<PB2);
DDRB &= ~((1<<PB2)|(1<<PB3));
PORTB &= ~(1<<PB1);
DDRB |= (1<<PB1);

// PCINT
GIMSK |= (1<<PCIE);
PCMSK = (1<<PCINT2);

// timer 0
TCCR0A = 0;
TCCR0B = (1<<CS01)|(1<<CS00);
TIMSK0 = (1<<TOIE0)|(1<<OCIE0B)|(1<<OCIE0A);

// ADC
ADMUX = (1<<ADLAR)|(1<<MUX1)|(1<<MUX0);
ADCSRA = (1<<ADEN)|(1<<ADSC)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);
ADCSRB = 0;
DIDR0 = 0;

sei();

// main loop
while(1){
//===плавный старт===

if (start_first==0){
// read ADC
while(ADCSRA & (1<<ADSC));
pwm_set = ADCH;
ADCSRA |= (1<<ADSC);
STOP =ADCH;
for (pwm_cur = 0xFF; pwm_cur > STOP; pwm_cur--){

for (int k = 0; k<10000; k++){ // ПОТОМ УБРАТЬ !!!

pwm_set =ADC;

}
}
start_first = 1;
}
//===================
// ZC sync
if (sync_flag){
sync_flag = 0;

// decrement startup timer
if (startup_cnt) startup_cnt--;


// update limiters
else

if (limit_en == 1){ // limit increment
if (limit < (0xFF - LIMIT_INC)) limit += LIMIT_INC;
else {
limit = 0xFF;
limit_en= 0;
}
}
else if (limit_en== 2){ // limit decrement
if (limit> LIMIT_INC) limit-= LIMIT_INC;
else {
limit= 0;
limit_en= 0;
}
}


uint8_t
pwm = (!pwm_set) ? 0 : (pwm_set < limit) ? pwm_set : limit;
pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> 8 ) ;
pwm_cur = (startup_cnt || (pwm_set < PWM_MIN)||((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;

// read ADC
while(ADCSRA & (1<<ADSC));
pwm_set = ADCH;
ADCSRA |= (1<<ADSC);

}
}

// exit
return 0;
}


ISR(TIM0_COMPB_vect){
if (pwm_cur){
pwm2_on();
sei();
if (pwm_ac){
_delay_us(PWM_AC_PULSE);
pwm2_off();
}
}
}

ISR(TIM0_OVF_vect){
pwm2_off(); // PWMs off
pwm_top = 0xFF; // update PWM top
OCR0B = pwm_cur; // reload PWMs
sync_flag = 1; pwm_ac = 0; // set Sync flag / reset AC flag
TIFR0 |= (1<<OCF0A)|(1<<OCF0B); // reset capture interrupts
}

// external interrupt on zero-cross
ISR(PCINT0_vect){
pwm2_off(); // PWMs off
pwm_top = TCNT0; // get PWM top
// uint8_t cnt = TCNT0; // get PWM top
TCNT0 = 0; // reset TCNT0
OCR0B = pwm_cur; // reload PWMs
sync_flag = pwm_ac = 1; // set Sync/AC flag
// pwm_top = ((uint16_t)cnt + pwm_top) >> 1; // filter PWM top
TIFR0 |= (1<<OCF0A)|(1<<OCF0B)|(1<<TOV0); // reset capture interrupts
}

ни фига не получается плавный пуск

Код: Выделить всё

			uint8_t
			pwm = (!pwm_set) ? 0 : (pwm_set < limit) ? pwm_set : limit;
			pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> 8);
			pwm_cur = (startup_cnt || (pwm_set < PWM_MIN)||((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;

а что тут написано? кто нибуть может прочитать и пояснить?

[oleg110592]

основоположников почитать - понятнее будет
2.11 Условные выражения

Инструкции

Код: Выделить всё

if (a › b)

 z = a;

else

 z = b;

пересылают в z большее из двух значений a и b. Условное выражение, написанное с помощью тернарного (т. е. имеющего три операнда) оператора "?: ", представляет собой другой способ записи этой и подобных ей конструкций. В выражении

выр1 ? выр2 : выр3

первым вычисляется выражение выр1. Если его значение не нуль (истина), то вычисляется выражение выр2, и значение этого выражения становится значением всего условного выражения. В противном случае вычисляется выражение выр3 и его значение становится значением условного выражения. Следует отметить, что из выражений выр2 и выр3 вычисляется только одно из них. Таким образом, чтобы установить в z большее из a и b, можно написать

Код: Выделить всё

z = (a › b) ? a: b; /* z = max(a, b) */

https://www.rulit.me/books/yazyk-progra ... section_34

[Serzh2000]

? : что это значит я понимаю...
я про другое спрашивал, что мы здесь считаем в этом именно коде

uint8_t
pwm = (!pwm_set) ? 0 : (pwm_set < limit) ? pwm_set : limit;
pwm = pwm_top - (((uint16_t)pwm * pwm_top) >> 8 );
pwm_cur = (startup_cnt || (pwm_set < PWM_MIN)||((pwm_top - pwm) < PWM_MAX_DIF)) ? 0 : pwm;