Část I: Jak monitorovat zpětnou vazbu lineárního aktuátoru?

In today’s guide, we will go over how to find out how much force a linear actuator is applying by monitoring the amount of current it is using. This will be one of our more advanced guides and will require some complex coding, calibrating and programming. We will be covering the monitoring of analog input and how it utilizes its functions. For this project, we’ll be using a MegaMoto Plus, a lineární aktuátor (používáme náš PA-14 miniaturní aktuátor), a Arduino Uno a napájení alespoň 12V.

Pro začátek budeme muset provést zapojení, abychom vše propojili. Začněte zapojením MegaMoto do Arduina, stačí MegaMoto umístit na Uno. Poté připojte vodič z terminálu BAT+ na MegaMoto k pinu Vin na Uno.

Nyní musíme připojit vodiče lineárních aktuátorů ke svorkám A a B na MegaMoto a připojit 12V zdroj napájení k BAT+ a GND k BAT-. Také budeme muset zapojit dvě tlačítka pro ovládání, a to tak, že každé z nich zapojíme mezi nevyužitý pin a GND. Doporučujeme zapojit tlačítka na nepájivé destičky.

Nyní je čas na programování s Arduinem Uno. Chceme naprogramovat tlačítka tak, aby ovládala, kdy se aktuátor vysune a zasune. Proud se začne monitorovat, jakmile se aktuátor vysune, a to nám umožní sledovat, zda překročí maximální proudový limit, či nikoli. Pokud limit překročí, aktuátor se automaticky zastaví, dokud se nerozhodnete jej zasunout. Vzhledem k tomu, že motory uvnitř aktuátorů mají při prvním zapnutí velký proudový špičkový nárůst, bude mít zadaný kód krátké zpoždění, než začne monitorovat proud. Tento kód bude schopen přečíst, kdy aktuátor dosáhne svých koncových spínačů, což je okamžik, kdy proud klesne na 0.

const int PovolitPin = 8;
konstantní int PWMPinA = 11;
const int PWMPinB = 3; // piny pro Megamoto
const int tlačítkoLeft = 4;
const int buttonRight = 5;//tlačítka pro pohyb motoru
const int CPin1 = A5; // zpětná vazba motoru

int levá západka = NÍZKÁ;
int rightlatch = LOW;//zámky motoru (používané pro logiku kódu)
int hitLimits = 0;//začátek od 0
int hitLimitsmax = 10;//hodnoty pro zjištění, zda byly dosaženy cestovní limity

longlastfeedbacktime = 0; // musí být dlouhá, jinak dojde k přetečení
int firstfeedbacktimedelay = 750; //první zpoždění pro ignorování aktuálního nárůstu
int feedbacktimedelay = 50; //zpoždění mezi cykly zpětné vazby, jak často chcete, aby byl motor kontrolován
currentTimefeedback = 0; // must be long, else it overflows
unceTime = 300; //amount to debounce buttons, lower values makes the buttons more sensitivelong lastButtonpress = 0; // timer for debouncing
dlouhý proudový čas odbouzení = 0;
int CRaw = 0; // vstupní hodnota pro aktuální hodnoty
int maxAmps = 0; // limit vypnutí 
bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//logika programu

void setup()
{
 Serial.begin(9600);
 pinMode(PovolitPin, VÝSTUP);
 pinMode(PWMPinA, VÝSTUP);
 pinMode(PWMPinB, OUTPUT);//Nastavení výstupů motoru
 pinMode(tlačítkoLevo, INPUT);
 pinMode(tlačítkoRight, INPUT);//tlačítka 
 digitalWrite(tlačítkoLeft, HIGH);
 digitalWrite(buttonRight, HIGH);//povolení interních pull-upů
 pinMode(CPin1, INPUT);//nastavení vstupu zpětné vazby
 aktuálníČasOdbounce = milisekundy();
 currentTimefeedback = 0;//Nastavení počátečních časů
 maxAmps = 15;// ZDE NASTAVTE MAXIMÁLNÍ PROUD
}//ukončení nastavení

void loop()
{
 latchButtons();//zkontrolujeme tlačítka, zda je potřeba je přesunout
 moveMotor();//kontrola západek, posunutí motoru dovnitř nebo ven
}//ukončení hlavní smyčky

void latchButtons()
{
 pokud (digitalRead(buttonLeft)==LOW)//vlevo je dopředu
 {
 currentTimedebounce = millis() - lastButtonpress;// kontrola času od posledního stisknutí
 pokud (currentTimedebounce> debounceTime && dontExtend == false)//jakmile se aktivuje dontExtend, ignorujte všechna stisknutí klávesy vpřed
 {
 leftlatch = !leftlatch;// pokud se motor pohybuje, zastaví, pokud stojí, začne se pohybovatfirstRun = true;// nastaví příznak firstRun pro ignorování aktuální špičky
 fullyRetracted = false; // jakmile se pohnete dopředu, nejste zcela zataženi
 lastButtonpress = millis();//uložení času posledního stisknutí tlačítka
 návrat;
 }//konec pokud
 }//konec tlačítka btnLEFT

 pokud (digitalRead(buttonRight)==LOW)//vpravo je pozpátku
 {
 currentTimedebounce = millis() - lastButtonpress;// kontrola času od posledního stisknutí
 pokud (currentTimedebounce> debounceTime)
 {
 rightlatch = !rightlatch;// pokud se motor pohybuje, zastaví, pokud stojí, začne se pohybovat
 firstRun = true;// nastaví příznak firstRun pro ignorování aktuálního vrcholu
 lastButtonpress = millis();//uložení času posledního stisknutí tlačítka
 návrat; 
 }//konec pokud
 }//konec tlačítka RIGHT
}//konec latchButtons

void moveMotor()
{
 pokud (leftlatch == HIGH) motorForward(255); //rychlost = 0-255
 pokud (levá západka == NÍZKÁ) motorStop();
 pokud (rightlatch == HIGH) motorBack(255); //rychlost = 0-255
 pokud (rightlatch == LOW) motorStop();
}//konec moveMotoru

void motorVpřed(int rychlost)
{
 zatímco (dontExtend == false && leftlatch == HIGH)
 {
 digitalWrite(PovolitPin, HIGH);
 analogWrite(PWMPinA, rychlost);
 analogWrite(PWMPinB, 0);//pohyb motoru
 if (firstRun == true) delay(firstfeedbacktimedelay); // větší zpoždění pro ignorování proudové špičky
 else delay(feedbacktimedelay); //malé zpoždění pro dosažení rychlosti
 získatZpětnouVezmětu();
 firstRun = false;
 latchButtons();//znovu zkontroluj tlačítka
 }//konec while
}//konec motoruVpřed

void motorBack (int speed)
{
 zatímco (pravá západka == vysoká)
 {
 digitalWrite(PovolitPin, HIGH);
 analogWrite(PWMPinA, 0);
 analogWrite(PWMPinB, speeed);//pohyb motoru
 pokud (firstRun == true) delay(firstfeedbacktimedelay);// větší zpoždění pro ignorování proudové špičky
 else delay(feedbacktimedelay); //malé zpoždění pro dosažení rychlosti
 získatZpětnouVezmětu();
 firstRun = false;
 latchButtons();//znovu zkontroluj tlačítka
 }//konec while
 dontExtend = false;//umožní motoru opětovné vysunutí po zasunutí
}//konec motorBack

void motorStop()
{
 analogWrite(PWMPinA, 0);
 analogWrite(PWMPinB, 0);
 digitalWrite(PovolitPin, LOW);
 firstRun = true;//po zastavení motoru znovu povolte firstRun, aby se zohlednily špičky spouštěcího proudu
}//ukončení zastavení motoru

void getFeedback()
{
 CRaw = analogRead(CPin1); // Čtení proudu
 pokud (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
 else hitLimits = 0; // kontrola, zda je motor na limitech a zda proud přestal protékat 
 pokud (hitLimits == hitLimitsmax && rightlatch == HIGH)
 {
 rightlatch = LOW; // zastavení motoru
 plněZataženo = true;
 }//konec pokud
 jinak pokud (hitLimits == hitLimitsmax && leftlatch == HIGH)
 {
 leftlatch = LOW;//zastavení motoru
 ZásahLimits = 0;
 }//konec pokud
 pokud (CRaw> maxAmps)
 {
 dontExtend = true;
 leftlatch = LOW; //zastaví se, pokud je zpětná vazba vyšší než maximum
 }//konec pokud
 lastfeedbacktime = millis();//uložení předchozího času pro příjem zpětné vazby
}//konec funkce getFeedback

Nové a vylepšené Miniaplikátor PA-01 (Vylepšení PA-14) je aktuální model, který nabízíme s řadou dalších výhod. Pro srovnání se podívejte na níže uvedené tabulky a upgradujte s důvěrou!

With this basic code, you will successfully monitor the feedback of your linear actuator. In Část II we will go more into how the code works and how to edit it to your liking. Hopefully, you found this post helpful and stay tuned for Part II in the coming weeks. If you'd like to order any units we used in this example or want to learn more about our produkty, prosím kontaktujte nás.