Линеен стъпков двигател - Синусоидално движение

[Bess]

Здравейте,
Използвам линеен стъпков двигател oyostepper. com / category-22-b0-Linear-Stepper-Motor. html, за да управлявам специфичен товар. Всичко работи добре, но получавам триъгълна вълнова картина, когато всъщност искам синусоидална вълна.
В момента тази картина произвежда различно изместване всеки път (но времето е ограничено до около 1 секунда). Следователно, карам двигателя да прави 350 стъпки (изместване от 1 мм) за 1 секунда и след това да се върти назад, но това произвежда триъгълна вълна.
Има ли някаква налична или лесна за изпълнение програма, която може да накара двигателя да прави серия от по-бързи стъпки, за да се приближи до синусоидална вълна?
Благодаря предварително.

[Vlad777]

Здравейте!

Разбирам, че се опитвате да задвижите линеен стъпков двигател по такъв начин, че крайното му изместване във времето да наподобява синусоида, но в момента получавате триъгълна вълна, което предполага равномерно движение напред и назад с постоянна скорост (и съответно постоянна стъпкова честота).

За да получите синусоидално изместване, трябва да модулирате скоростта на стъпките така, че да следва производната на синусоидата – т.е. косинусоиден профил на скоростта, което означава:

Бързи стъпки около средата на движението (когато синусоидата е стръмна)

По-бавни стъпки в крайните точки (където синусоидата е полегата)

Решение с прост скрипт (пример с Arduino)
Концепция:

Разделяте 1 синусоиден цикъл на N малки стъпки (напр. 350).

За всяка стъпка изчислявате моментното време за изчакване (delay) до следващата стъпка въз основа на производната на синусоида.

Използвате delayMicroseconds() или micros() за контрол на тайминга.

Примерен код (C++ / Arduino):

const int steps = 350;
const float amplitude = 1.0; // в мм или стъпки, зависи от нуждите
const int stepPin = 3;
const int dirPin = 4;
const float duration = 1.0; // seconds

void setup() {
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}

void loop() {
digitalWrite(dirPin, HIGH); // напред

unsigned long startTime = micros();
for (int i = 0; i < steps; i++) {
float t = (float)i / steps; // 0 to 1
float sinPosition = sin(PI * t); // 0 -> π
float speedProfile = abs(cos(PI * t)); // derivative of sin

float normalizedDelay = 1.0 / (speedProfile + 0.01); // избегнете делене на 0
unsigned long delayTime = normalizedDelay * 300; // скалирайте до нужните µs

digitalWrite(stepPin, HIGH);
delayMicroseconds(2);
digitalWrite(stepPin, LOW);

delayMicroseconds(delayTime);
}

delay(100); // пауза

digitalWrite(dirPin, LOW); // назад
// Повторете същия цикъл за обратно движение
}

Други възможности:

GRBL + Sine G-code генерация – можете да генерирате G-code път със синусоидална траектория и да използвате GRBL-контролер (или друг CNC firmware).

Python + Serial (за по-гъвкаво управление) – използвайте Python скрипт, който изчислява таймингите и изпраща команди през сериен порт към драйвера.

Микростъпково управление – използвайте драйвер с поддръжка на микростъпки (напр. 1/16, 1/32), което ще направи движението по-гладко и ще улесни доближаването до синусоида.

Визуализация

Ако желаете, мога да ви помогна да генерираме Excel / Python графика, която да показва:

Сравнение между триъгълна, синусоидална и "скоростно-модулирана" траектория.

Таблица със закъснения/тайминги за всяка стъпка.

Ако ми кажете:

С какъв контролер работите (Arduino, Raspberry Pi, PLC, и т.н.)

Какъв драйвер използвате (A4988, TMC2209 и т.н.)

мога да ви предложа конкретен пример за хардуера ви.

Искате ли да го направим с Python или с Arduino код според вашия случай?

[group®]

Здравейте!
Разбирам проблема, с който се сблъсквате. Триъгълната вълна, която получавате, е естествен резултат от постоянното ускорение и забавяне, когато правите фиксиран брой стъпки в една посока, след което обръщате посоката. За да получите синусоидална вълна с линеен стъпков двигател, трябва да варирате скоростта на стъпките през цикъла.
Защо се получава триъгълна вълна?
Когато задавате на двигателя да прави 350 стъпки за 1 секунда и след това да се връща обратно, вие по същество му задавате постоянна скорост във всяка посока. Преминаването от движение напред към движение назад създава остри върхове, което води до триъгълна вълна на изместването спрямо времето.
Как да генерирате синусоидална вълна?
За да се приближите до синусоидална вълна, трябва да променяте скоростта на двигателя така, че тя да е:
* Най-висока в средата на движението (когато изместването преминава през нулата).
* Най-ниска (нулева) в крайните точки на изместването (върховете на синусоидата), където двигателят променя посоката си.
Това означава, че трябва да изчислявате броя на стъпките или времето между стъпките, базирайки се на синусоидална функция.
Програма за генериране на синусоидална вълна
Ето какъв е общият подход за създаване на такава програма, която можете да адаптирате за вашия контролер (например Arduino, Raspberry Pi или друг микроконтролер):
* Дефинирайте параметрите на синусоидата:
* Амплитуда: Това е максималното изместване в една посока (при вас 350 стъпки или 1 мм).
* Период: Времето, за което двигателят извършва един пълен синусоидален цикъл (например 2 секунди за един пълен цикъл напред-назад, ако вашият текущ цикъл е 1 секунда напред и 1 секунда назад).
* Фаза: Може да се използва за отместване на началната точка.
* Изчислете позицията във всеки момент от време:
Използвайте функцията `position(t) = Amplitude * sin(2 * \pi * Frequency * t)`
където:
* t е текущото време.
* Frequency е `1 / Period`.
* Изчислете скоростта (броя стъпки за малък интервал от време):
Скоростта е производната на позицията спрямо времето. За дискретни стъпки това означава да изчислите разликата в позицията между два последователни момента във времето.
`velocity(t) = d(position)/dt`
На практика, ще изчислявате желаната позиция за всеки много малък интервал от време (dt) и ще правите стъпки, за да достигнете тази позиция. Броят на стъпките за всеки dt ще варира, симулирайки синусоидална скорост.
* Управлявайте двигателя:
На базата на изчислената скорост, подавайте импулси на стъпковия двигател. Колкото по-висока е изчислената скорост, толкова по-бързо трябва да се подават импулсите (по-кратко време между тях).
Примерна логика (псевдокод):
// Параметри
double amplitude = 350.0; // Максимално изместване в стъпки
double period = 2.0; // Период на синусоидата в секунди (напред и назад)
double frequency = 1.0 / period;
double timeStep = 0.001; // Малък интервал от време за изчисления (напр. 1 ms)
double currentTime = 0.0;
double currentPosition = 0.0;
double previousPosition = 0.0;

// Цикъл за управление
while (true) { // Можете да го ограничите до определен брой цикли
// Изчисляване на желаната позиция в текущия момент
double desiredPosition = amplitude * sin(2 * PI * frequency * currentTime);

// Изчисляване на броя стъпки за този интервал
int stepsToTake = round(desiredPosition - previousPosition);

// Определяне на посоката
if (stepsToTake > 0) {
// Задаване на посока напред
for (int i = 0; i < stepsToTake; i++) {
// Извършване на една стъпка напред
// (изпращане на импулс към двигателя)
// Забавяне за контрол на скоростта, ако е необходимо
}
} else if (stepsToTake < 0) {
// Задаване на посока назад
for (int i = 0; i < abs(stepsToTake); i++) {
// Извършване на една стъпка назад
// (изпращане на импулс към двигателя)
// Забавяне за контрол на скоростта, ако е необходимо
}
}

previousPosition = desiredPosition;
currentTime += timeStep;

// Можете да добавите закъснение тук, за да синхронизирате с real-time
// Например: delay(timeStep * 1000); ако timeStep е в секунди
}

Реализация и съвети:
* Микростеппинг (Microstepping): Ако вашият драйвер за стъпков двигател поддържа микростеппинг, използвайте го. Той ще направи движението много по-плавно и ще намали вибрациите, което ще ви помогне да се доближите повече до гладка синусоида. Вместо 350 "цели" стъпки, може да правите 350 * 16 (ако използвате 1/16 микростеппинг) микростъпки.
* Контролер: Arduino или други микроконтролери са идеални за тази задача, тъй като могат да генерират прецизни импулси с точно време. Ще ви трябва стъпков драйвер (например A4988, DRV8825) за вашия линеен стъпков двигател.
* Времеви прекъсвания (Timers/Interrupts): За по-прецизен контрол на времето между стъпките, особено при високи скорости, използвайте таймери на микроконтролера, а не функция delay().
* Регулиране на скоростта: Вместо просто да "извършвате стъпки", трябва да контролирате интервала между импулсите. Колкото по-малък е интервалът, толкова по-бърза е скоростта. За синусоидална вълна, скоростта трябва да е функция на косинуса, т.е. `speed(t) = A * cos(2 * \pi * F * t)`.
Налични библиотеки и ресурси:
За Arduino има библиотеки като AccelStepper, които могат да улеснят управлението на стъпкови двигатели с профили на ускорение/забавяне. Въпреки че не генерират директно синусоидална вълна като изходен сигнал, можете да ги използвате, за да задавате желаната позиция или скорост на малки интервали, така че да проследяват синусоидална крива.
Надявам се тази информация да ви е полезна! Ако имате конкретен контролер или среда за програмиране, мога да ви насоча по-точно.