Home » The Best arduino motor New Update

The Best arduino motor New Update

by Tratamien Torosace

You are viewing this post: The Best arduino motor New Update

Neues Update zum Thema arduino motor


Table of Contents

135 motor Projects – Arduino Project Hub Aktualisiert

Interested in motor? Explore 135 projects tagged with ‘motor‘. Find these and other hardware projects on Arduino Project Hub.

+ ausführliche Artikel hier sehen

Read more

Dies ist eine Modellschaltung, die die Geschwindigkeit und die Richtung eines Gleichstrommotors ohne die H-Brücke steuern kann (es ist eine Alternative zur H-Brücke).

28BYJ-48 stepper motor and ULN2003 Arduino (Quick tutorial for beginners) New

Video ansehen

Weitere Informationen zum Thema arduino motor

In this quick Arduino tutorial, I will show you how to use 28BYJ-48 stepper motor with ULN2003 driver. Because this is a quick Arduino tutorial we will focus on the most important things you need to know to get it working in 5 minutes. Enjoy!
28BYJ-48 with driver: https://amzn.to/3gAN2qH
Arduino: https://goo.gl/BEUm5X
Code: https://github.com/NikodemBartnik/ArduinoTutorials
Support my projects on Patreon → https://www.patreon.com/nikodembartnik
This is the second video of my Arduino tutorials about basic sensors and output devices that you can use with Arduino. I want to keep all of them under 5 minutes to make them short so that if you want to use something in your project you can quickly go through the tutorial and start making your own project.
Instagram: https://goo.gl/JLFLtf

arduino motor Einige Bilder im Thema

 Update 28BYJ-48 stepper motor and ULN2003 Arduino (Quick tutorial for beginners)
28BYJ-48 stepper motor and ULN2003 Arduino (Quick tutorial for beginners) New

Arduino – Motor PID Speed Control – Arduino Project Hub Neueste

The Arduino Pro Mini is used to store motor controls, PID algorithms, and to communicate with the PC (through COM Port). The computer should have HMI made by Visual Studio to communicate with Arduino. HMI will show motor speed graphs and change motor speed settings.

+ Details hier sehen

Read more

Link zum Kauf:

1

Motor mit Encoder: https://amzn.to/2NwsNxH

2

H-Brücke: https://amzn.to/2QS2FeI

3

Arduino Pro Mini: https://amzn.to/2xy4yFn

Kaufen Sie elektronische Komponenten auf utsource.net

Einführung

Mit der PID-Regelung kann die Drehzahl eines Motors exakt archiviert werden

Dieser Artikel stellt hauptsächlich die Erstellung eines Programms für den Arduino Pro Mini auf Ihrem Computer (unter Verwendung von Visual Studio) vor, um die Motordrehzahl durch einen PID-Algorithmus zu steuern

Abb

1

Allgemeine Verbindung

Der Arduino Pro Mini wird zum Speichern von Motorsteuerungen, PID-Algorithmen und zur Kommunikation mit dem PC (über den COM-Port) verwendet

Der Computer sollte über eine von Visual Studio erstellte HMI verfügen, um mit Arduino zu kommunizieren

Die HMI zeigt Motorgeschwindigkeitsdiagramme an und ändert die Motorgeschwindigkeitseinstellungen

Abb

2

HMI auf dem Computer (hergestellt von Visual Studio)

Gehen wir ins Detail

Benötigte Hardware:

1

Motor mit Encoder

2

H-Brücken-PCB

3

Arduino Pro-Mini

4

UART-Leiterplatte

5.Computer (mit Visual Studio)

Schritt 1

Hardwareverbindung

Dieser Artikel erwähnt keine Verbindungsdetails; Es basiert auf einem früheren Artikel, der unter diesem Link zu finden ist

Schritt 2

Code mit dem Arduino

Leere Schleife () {

wenn (stringComplete) {

// Lösche den String, wenn der COM-Empfang abgeschlossen ist

mySt = “”; //Hinweis: Im folgenden Code wird mySt nicht leer, mySt ist leer bis ‘

‘ Ist angekommen

stringComplete = falsch;

}

//Befehl von Visual Studio empfangen

if (mySt.substring(0,8) == “vs_start”){

digitalWrite (pin_fwd, 1); // Motor laufen lassen, vorwärts laufen

digitalWrite (pin_bwd, 0);

motor_start = wahr;

}

if (mySt.substring(0,7) == “vs_stop”){

digitalWrite (pin_fwd, 0);

digitalWrite (pin_bwd, 0); // Motor stoppen

motor_start = falsch;

}

if (mySt.substring(0,12) == “vs_set_speed”){

set_speed = mySt.substring(12,mySt.length()).toFloat(); //String nach set_speed erhalten

}

if (mySt.substring(0,5) == “vs_kp”){

kp = mySt.substring(5,mySt.length()).toFloat(); //String nach vs_kp abrufen

}

if (mySt.substring(0,5) == “vs_ki”){

ki = mySt.substring(5,mySt.length()).toFloat(); //String nach vs_ki erhalten

}

if (mySt.substring(0,5) == “vs_kd”){

kd = mySt.substring(5,mySt.length()).toFloat(); //String nach vs_kd abrufen

}

}

void detect_a() {

Encoder+=1; // Encoder bei neuem Impuls erhöhen

m_direction = digitalRead (pin_b); // Richtung des Motors lesen

}

ISR(TIMER1_OVF_vect) // Dienstroutine unterbrechen – Tick alle 0,1 Sek

{

TCNT1 = Timer1_Zähler; // Timer setzen

pv_speed = 60,0 * (Encoder / 200,0) / 0,1; // Motordrehzahl berechnen, Einheit ist rpm.encoder=0;

// Geschwindigkeit ausdrucken

if (Serial.verfügbar() <= 0) {

Serial.print (“Geschwindigkeit”);

Serial.println (pv_speed); //Geschwindigkeitswert (U/min) in Visual Studio drucken

}

//PID-Programm

wenn (motor_start){

e_speed = set_speed – pv_speed;

pwm_pulse = e_speed*kp + e_speed_sum*ki + (e_speed – e_speed_pre)*kd;

e_speed_pre = e_speed; // letzten (vorherigen) Fehler speichern

e_speed_sum += e_speed; // Summe der Fehler

if (e_speed_sum >4000) e_speed_sum = 4000;

if (e_speed_sum <-4000) e_speed_sum = -4000;

}

anders{

e_speed = 0;

e_speed_pre = 0;

e_speed_sum = 0;

pwm_pulse = 0;

}

// neue Geschwindigkeit aktualisieren

if (pwm_pulse <255 & pwm_pulse>0){

analogWrite (pin_pwm, pwm_pulse); // Motordrehzahl einstellen

}

anders{

wenn (pwm_pulse>255){

analogWrite (pin_pwm, 255);

}

anders{

analogWrite (pin_pwm, 0);

}

}

}

Zu Beginn des Programms erhält es Befehle vom Computer (Motor starten/stoppen; Motorgeschwindigkeitseinstellungen; kP, kI, kD-Verstärkung von PID)

Als nächstes kommt void detect_a(): Dies ist ein Codierer für die Summenberechnung, der für die Geschwindigkeitsberechnung in der Timer-Interrupt-Routine verwendet wird

Timer-Interrupt-Routine ISR(TIMER1_OVF_vect): alle 0,1 wird dieses Programm aufgerufen; Der Inhalt umfasst: (1) Berechnen der Motordrehzahl (2) Senden der Motordrehzahl an den Computer (3) Berechnen des PWM-Impulses (basierend auf dem PID-Algorithmus) (4) Push-Ergebnis der PWM an die H-Brücke

Der gesamte Code für Arduino Pro mini kann unter diesem Link heruntergeladen werden

Schritt 3

Code auf dem Computer

Visual Studio 2012 wird verwendet, um HMI-Programme zu erstellen, in denen: (1) Geschwindigkeitseinstellungen an Arduino senden (2) PID-Verstärkung (kP, kI, kD) an Arduino senden (3) Motordrehzahl empfangen -> im Diagramm anzeigen

Abb

3

Visual Studio-Programm

Der gesamte Code für das Visual Studio-Programm kann unter diesem Link heruntergeladen werden

Informationen zum Erstellen eines Visual Studio-Programms finden Sie in den detaillierten Schritten in diesem Artikel

Im Allgemeinen hat der Code Folgendes:

#pragma Endbereich

private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e) {

serialPort1->Öffnen();

timer1->Start();

mStr=”0″;

i=300;

}

private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) {

serialPort1->WriteLine(“vs_set_speed”+textBox1->Text); // set_speed an Arduino senden

serialPort1->WriteLine(“vs_kp”+textBox2->Text); // kP an Arduino senden

serialPort1->WriteLine(“vs_ki”+textBox3->Text); // kI an Arduino senden

serialPort1->WriteLine(“vs_kd”+textBox4->Text); // kD an Arduino senden

}

private: System::Void timer1_Tick(System::Object^ sender, System::EventArgs^ e) {

String^ Länge;

length=mStr->Length.ToString();

if(mStr->Substring(0,5)==”speed”){

speed=mStr->Substring(5,System::Convert::ToInt32(length)-6);

label1->Text=Geschwindigkeit;

// Motordrehzahl in Diagramm drucken

this->chart1->Series[“Series1”]->Points->AddXY(i,System::Convert::ToDouble(speed));

i++;

this->chart1->ChartAreas[“ChartArea1”]->AxisX->Minimum=i-300; // x-Achse verschieben

}

}

private: System::Void serialPort1_DataReceived(System::Object^ sender, System::IO::Ports::SerialDataReceivedEventArgs^ e) {

mStr=serialPort1->ReadLine();

}

private: System::Void button2_Click(System::Object^ sender, System::EventArgs^ e) {

serialPort1->WriteLine(“vs_start”); //starte den Motor

}

private: System::Void button3_Click(System::Object^ sender, System::EventArgs^ e) {

serialPort1->WriteLine(“vs_stop”); // Motor stoppen

}

Ergebnis

Arduino Tutorial 37: Understanding How to Control DC Motors in Projects New

Video ansehen

Weitere Informationen zum Thema arduino motor

You guys can help me out over at Patreon, and that will help me keep my gear updated, and help me keep this quality content coming:
https://www.patreon.com/PaulMcWhorter
This lesson shows you how to control a DC motor using arduino and a L293D Motor Controller. It is important to make sure to use motors compatible with the current capabilities of your control chip and power supply.
You can get the kit I am using for this series at the following link:
https://amzn.to/2I7N4Ek
Follow These lessons on our WEB site:
https://toptechboy.com/arduino-tutorial-37-understanding-how-to-control-dc-motors-in-projects/
[Disclosure of Material Connection: I am a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to amazon.com. This means if you visit the link and purchase the item, I will receive an affiliate commission. Regardless, I only recommend products or services I use personally and believe will add value to my readers.]
#Arduino

arduino motor Sie können die schönen Bilder im Thema sehen

 New Arduino Tutorial 37: Understanding How to Control DC Motors in Projects
Arduino Tutorial 37: Understanding How to Control DC Motors in Projects New Update

Motor Driver LibraryArduino Reference Update

Motor Driver Library. Device Control. Motor Driver Library for Arduino Shields with L293D and 74HC595 Though The Old Adafruit Motor Shield has been discontinued, a lot of Chinese sellers continue to manufacture this Shield at a low cost, and it …

+ mehr hier sehen

Read more

Zweifel an der Verwendung von Github? Erfahren Sie in diesem Tutorial alles, was Sie wissen müssen

Finden Sie etwas, das verbessert werden kann? Schlagen Sie Korrekturen und neue Dokumentationen über GitHub vor

Motortreiberbibliothek

Gerätesteuerung

Motortreiberbibliothek für Arduino Shields mit L293D und 74HC595

Obwohl das Old Adafruit Motor Shield eingestellt wurde, stellen viele chinesische Verkäufer dieses Shield weiterhin zu niedrigen Kosten her, und es ist ein gutes Shield für die Durchführung einer kleinen Robotikklasse

Mit dieser Bibliothek können Sie auf alle motorischen Kanäle zugreifen und diese steuern

Autor: CuriosityGym

Betreuer: Rupin

Lesen Sie die Dokumentation

Gehen Sie zum Repository

Kompatibilität

Diese Bibliothek ist mit der avr-Architektur kompatibel, sodass Sie sie auf den folgenden Arduino-Boards verwenden können sollten:

Freigaben

Um diese Bibliothek zu verwenden, öffnen Sie den Bibliotheksmanager in der Arduino IDE und installieren Sie ihn von dort.

Arduino DC Motor Control Tutorial – L298N | H-Bridge | PWM | Robot Car Update

Video unten ansehen

Weitere hilfreiche Informationen im Thema anzeigen arduino motor

https://howtomechatronics.com/tutorials/arduino/arduino-dc-motor-control-tutorial-l298n-pwm-h-bridge/ ► Find more details, circuit schematics and source codes on my official website.
In this Arduino Tutorial we will learn how to control DC motors using Arduino. We well take a look at some basic techniques for controlling DC motors and make two example through which we will learn how to control DC motors using the L298N driver and the Arduino board. 
If you enjoy and find the content that I make useful, please consider supporting me on Patreon: https://www.patreon.com/howtomechatronics
Parts list (check website article for full list, affiliate links):
Amazon.com:
L298N Driver: https://amzn.to/2KwGM0o
12V High Torque DC Motor: https://amzn.to/2HoYuUe
Arduino Board: https://amzn.to/2Ccd5kC
Banggood.com:
L298N Driver: http://bit.ly/3c7tOY4
12V High Torque DC Motor: http://bit.ly/39eup8s
Arduino Board: http://bit.ly/2YioMjH
Visit HowToMechatronics.com for more Tutorials, Tips, Projects and How It Works videos:
► https://howtomechatronics.com/
Like my page on Facebook:
► https://www.facebook.com/howtomechatronics

arduino motor Einige Bilder im Thema

 Update Arduino DC Motor Control Tutorial - L298N | H-Bridge | PWM | Robot Car
Arduino DC Motor Control Tutorial – L298N | H-Bridge | PWM | Robot Car Update

Arduino DC motor – JavaTpoint Update

Arduino DC motor. The DC motor is considered as the simplest motor, which has various applications ranging from households to industries. Example includes an electric window in cars, electric vehicles, elevators, etc.. The principle of the DC …

+ hier mehr lesen

Read more

next → ← prev Arduino DC-Motor Der DC-Motor gilt als der einfachste Motor, der vielfältige Anwendungen hat, die von Haushalten bis hin zu Industrien reichen

Beispiele sind elektrische Fensterheber in Autos, Elektrofahrzeugen, Aufzügen usw

Das Prinzip der Gleichstrommotoren basiert auf elektromagnetischer Induktion

Das bedeutet, dass die Drehung des Motors von der Kraft abhängt, die durch die Magnetfelder erzeugt wird

Es wandelt elektrische Energie in mechanische Energie um

Solche Motoren können mit Gleichstrom betrieben werden

Lassen Sie uns diskutieren, wie der Gleichstrommotor funktioniert

Funktionsweise des Gleichstrommotors Der Gleichstrommotor besteht aus einem Stator, einem Rotor, einem Anker und einem Kommutator

Der Kommutator wird mit Bürsten geliefert

Im Stator befinden sich zwei stationäre Magnete, die für die Erzeugung des Magnetfelds verantwortlich sind

Der im Gleichstrommotor vorhandene Anker trägt den Wechselstrom

Elektrische Energie wird durch den Anker in mechanische Energie in Form von Drehmoment umgewandelt

Es überträgt diese mechanische Energie über die Welle weiter

Der Kommutator ist als elektrischer Schalter definiert

Es kann auch die Richtung des Stroms zwischen dem externen Stromkreis und dem Motor umkehren

Die Bürsten fungieren als Vermittler zwischen der externen Stromversorgung und den rotierenden Spulen

Der Eisenkern in der Mitte ist mit isolierten Drähten umwickelt, die sich auf das Magnetfeld konzentrieren, wenn Strom durch die Drähte fließt

Die Wicklungen aus isoliertem Draht haben viele Windungen um den Kern des Motors

Die Drahtenden sind mit dem Kommutator verbunden

Der Kommutator erregt ferner die Ankerspulen und verbindet die Stromversorgung und die rotierenden Spulen durch Bürsten

Vorteile von Gleichstrommotoren Die Vorteile der Verwendung von Gleichstrommotoren sind unten aufgeführt: Niedrige Kosten

Einfache Motordrehzahlregelung

Hohe Zuverlässigkeit

Minimale Wartung

Hohes Anlaufdrehmoment

Schneller Start

Variable Geschwindigkeiten

Oberschwingungsfrei Der DC-Motor sieht aus wie im folgenden Bild: Fangen wir mit dem Projekt an

Wir werden zwei Projekte des Gleichstrommotors diskutieren

Projekt 1: Hier besprechen wir die einfache Verbindung eines Gleichstrommotors mit dem Arduino-Board mit Diode, Transistor und Widerstand

Erforderliche Hardware Die im Projekt erforderlichen Komponenten sind unten aufgeführt: Arduino UNO R3 Board

Steckbrett

Ein Widerstand von 2,2 kOhm

Transistor (NPN)

Diode

Gleichspannungs Motor

Schaltdrähte Struktur des Projekts Die Struktur des Projekts ist unten dargestellt: Skizze Betrachten Sie den folgenden Code: int PinOFmotor = 10; // PIN 10 des Arduino wird auf die Variable initialisiert // der Pin muss ein PWM-Pin sein Void setup () { PinMode (PinOFmotor, OUTPUT); aufrechtzuerhalten

Leere Schleife () { DigitalWrite (PinOFmotor, HIGH); Verzögerung (1000); digitalWrite (PinOFmotor, LOW); Verzögerung (1000); } Schritte zum Hochladen des Codes auf das Board Die Schritte sind unten aufgeführt: Öffnen Sie die Arduino IDE.

Wählen Sie den Typ des Boards aus Tools -> Board -> Arduino UNO.

Wählen Sie den Port aus Tools -> Port -> COM.

Laden Sie die obige Skizze in den Anschlussplan hoch

Verbindung Die Schritte zum Herstellen der Verbindung sind unten aufgeführt: Verbinden Sie ein Ende des Widerstands mit Pin 10 (PWM) der Arduino-Platine

Verbinden Sie das andere Ende des Widerstands mit dem mittleren Pin des Transistors

Verbinden Sie einen Endanschluss des Transistors an den GND-Pin des Arduino und einen anderen Endanschluss an die Diode

Verbinden Sie den bandseitigen Anschluss der Diode mit dem 5-V-Pin der Arduino-Platine

Verbinden Sie einen Endanschluss des Gleichstrommotors mit dem bandseitigen Anschluss von die Diode.

Verbinden Sie einen anderen Endanschluss des Gleichstrommotors mit dem anderen Ende der Diode

Verbindungsdiagramm Wir zeigen die Verbindung mit dem Simulator, damit die Verbindungen klarer und präziser werden

Wir können die gleiche Verbindung mit den Hardwaregeräten herstellen

Nach dem Herstellen der Verbindungen dreht sich der Motor

Projekt 2: Hier besprechen wir die Verbindung eines DC-Getriebemotors mit dem Arduino-Board unter Verwendung des L293D H-Bridge-Motortreibers

Lassen Sie uns die Notwendigkeit diskutieren, den L293D H-Brücken-Motortreiber mit dem Gleichstrommotor zu verwenden

L293 ist als Motortreiber-IC definiert, der es dem Gleichstrommotor ermöglicht, in jede Richtung zu fahren

Es kann auch gleichzeitig zwei Gleichstrommotoren steuern

Es ist ein 16-poliger integrierter Schaltkreis (IC)

Es empfängt Signale von dem auf der Arduino-Platine vorhandenen Mikroprozessor und überträgt dieses Signal an den Motor

Es hat zwei VCC- oder Spannungsstifte, wobei ein Stift Strom für seine Arbeit zieht und ein anderer verwendet wird, um Spannung an den Gleichstrommotor zu liefern

Der Motor benötigt normalerweise einen hohen Strom für seinen Betrieb

Wir können den auf dem Arduino vorhandenen Mikrocontroller verwenden, aber hoher Strom könnte den Mikrocontroller beschädigen

Um dies zu überwinden, wird der Motortreiber verwendet

L293D ist einer der beliebtesten Motortreiber, die zum Antrieb von Gleichstrommotoren verwendet werden

Es kann Gleichstrommotoren bis zu einer Strombelastung von 1 Ampere betreiben

Die vier am L293D-Treiber vorhandenen Ausgänge machen ihn auch zum Ansteuern des 4-Draht-Schrittmotors geeignet

Wir können auch Servomotoren mit dem L293D-Treiber antreiben

L293D-Pinbelegung Die Pinbelegung des L293D ist unten dargestellt: Erforderliche Hardware Die im Projekt erforderlichen Komponenten sind unten aufgeführt: Arduino UNO R3-Board

Steckbrett

DC-Getriebemotor

Einstellbare 30-V-Versorgung

Sprungdrähte

L293D H-Brücken-Motortreiber-Skizze Betrachten Sie den folgenden Code: #define MOTOR_1 11 // PWM-Pin 11 #define MOTOR_A 10 // PWM-Pin 10 // wir können es auch mit den anderen PWM-Pins des Arduino verbinden #define MOTOR_B 8 / / digitaler I/O-Pin #define slow 64 #define normal 128 #define fast 255 int Speed; // Initialisierung der Drehzahlvariable // erstellte Funktionen void Forward_Rev(void) { analogWrite(MOTOR_1, Speed); digitalWrite (MOTOR_A, HOCH); digitalWrite (MOTOR_B, NIEDRIG); aufrechtzuerhalten

See also  Best optiker geöffnet corona New

void Backward_Rev (void) {analogWrite (MOTOR_1, Geschwindigkeit); digitalWrite (MOTOR_A, NIEDRIG); digitalWrite (MOTOR_B, HOCH); aufrechtzuerhalten

void Forward_ramp_up (void) {digitalWrite (MOTOR_A, HIGH); digitalWrite (MOTOR_B, NIEDRIG); for (int i=0; i<255; i++) // Schleife gestartet //Wert von 0 auf 255 gesetzt { analogWrite(MOTOR_A, i); Verzögerung (15); // Verzögerungszeit in Millisekunden aufrechtzuerhalten

aufrechtzuerhalten

void Forward_ramp_down (void) {digitalWrite (MOTOR_A, HIGH); digitalWrite (MOTOR_B, NIEDRIG); for (int i=255; i>=0; i–) // Schleife in umgekehrter Richtung setzen // Wert von 255 auf 0 setzen (rückwärts) { analogWrite (MOTOR_A, i); Verzögerung (15); } } // gleiche Anweisung, aber innerhalb einer anderen Funktion void Backward_ramp_up (void) { digitalWrite (MOTOR_A, LOW); digitalWrite (MOTOR_B, HOCH); for (int i=0; i<255; i++) {analogWrite(MOTOR_A, i); Verzögerung (15); // wir können die Verzögerungszeit gemäß den Anforderungen ändern aufrechtzuerhalten

aufrechtzuerhalten

void Backward_ramp_down (void) {digitalWrite (MOTOR_A, LOW); digitalWrite (MOTOR_B, HOCH); for (int i=255; i>=0; i–) {analogWrite(MOTOR_A, i); Verzögerung (15); aufrechtzuerhalten

aufrechtzuerhalten

void Bremse (void) {digitalWrite (MOTOR_A, HIGH); digitalWrite (MOTOR_B, HOCH); aufrechtzuerhalten

void setup () {Serial.begin (9600); // bps-Rate von 9600 Serial.println (“DC-Motortest mit L293D”); PinMode (MOTOR_1, AUSGANG); PinMode (MOTOR_A, AUSGANG); PinMode (MOTOR_B, AUSGANG); } Leere Schleife () {Geschwindigkeit = langsam; // Langsame Geschwindigkeit // Wir können den Wert je nach erforderlicher Geschwindigkeit als schnell, langsam und normal ändern // der Motor dreht sich entsprechend der angegebenen Geschwindigkeit // zum Beispiel bewirkt schnell, dass er sich mit hoher Geschwindigkeit bewegt // Wir können auch weitere Parameter mit #define Forward_Rev() hinzufügen; Verzögerung (1000); Bremse(); Verzögerung (500); Backward_Rev(); Verzögerung (1000); Bremse(); Verzögerung (500); Forward_ramp_up(); Forward_ramp_down(); Backward_ramp_up(); Backward_ramp_down(); // die Anweisung innerhalb der Funktionen wird immer wieder ausgeführt // der Motor dreht sich vorwärts und rückwärts } Verbindung Die Schritte zum Herstellen der Verbindung sind unten aufgeführt: Verbinden Sie den roten Anschluss der Stromversorgung mit dem VCC des L293D

.Verbinden Sie den schwarzen Anschluss der Stromversorgung mit dem GND des L293D.

Verbinden Sie beide Anschlüsse des Motors mit den Ausgangspins 1 und 2 des L293D-Treibers.

Verbinden Sie den Eingangspin 2 des L293D mit dem digitalen Pin 8 des Arduino-Boards.

Verbinden Sie den Enable-Pin 1 und den Eingang 1 mit den PWM-Pins 10 und 11 des Arduino-Boards.

Verbinden Sie VCC des L293D-Treibers mit dem 5V-Pin des Arduino-Boards.

Verbinden Sie GND des L293D-Treibers mit dem GND-Pin von das Arduino-Board

Verbindungsdiagramm Wir zeigen die Verbindung mit dem Simulator, damit die Verbindungen klarer und präziser werden

Wir können die gleiche Verbindung mit den Hardwaregeräten herstellen

Der Geschwindigkeitsmodus „Langsam“ bewirkt, dass sich der Motor mit einer langsamen Geschwindigkeit dreht

Wir können den Modus auch auf schnell oder normal ändern, wie im Code erklärt

Wir können dem Code gemäß unseren Anforderungen auch weitere Geschwindigkeitsparameter hinzufügen

Nächstes ThemaArduinoNano

← zurück weiter →

Arduino Tutorial – 10. Der Schrittmotor (#10) New

Video unten ansehen

Neues Update zum Thema arduino motor

► MaxTechTV auf Instagram http://instagram.com/MaxTechTV
► MaxTechTV auf Facebook http://www.facebook.com/MaxTechTV
► MaxTechTV auf Twitter http://twitter.com/MaxTechTV
► Zweitkanal: https://www.youtube.com/channel/UC2Rhn2xu5kCLaLxyj8uAR-w
► MaxTechTV’s Homepage http://maxtechtv.de

Dokumentation zum Shield : https://learn.adafruit.com/adafruit-motor-shield-v2-for-arduino
Das Shield im Watterott Online Shop: http://www.watterott.com/de/Arduino-Motor-Shield
(Dieser Link ist nicht gesponsert. Ich finde den Shop und den Service aus eigener Erfahrung super!)
Alle Links findet ihr hier :
http://maxtechtv.de/?p=116

arduino motor Einige Bilder im Thema

 Update New Arduino Tutorial - 10. Der Schrittmotor (#10)
Arduino Tutorial – 10. Der Schrittmotor (#10) Update

Arduino Brushless Motor Control Tutorial | ESC | BLDC … New Update

02/02/2019 · Code language: Arduino (arduino) Description: So, we need to define the Servo library, because with the servo library we can easily generate the 50Hz PWM signal, otherwise the PWM signals that the Arduino generates are at different frequencies.Then we need to create a servo object for the ESC control and define a variable for storing the analog input from the …

+ Details hier sehen

Read more

In diesem Tutorial lernen wir, wie man einen bürstenlosen Motor mit Arduino und ESC steuert

Falls Sie mehr Details zur Funktionsweise von BLDC-Motoren wünschen, können Sie den anderen Artikel lesen oder sich das folgende Video ansehen, das das Funktionsprinzip eines bürstenlosen Motors erklärt und erklärt, wie man einen mit Arduino und ESC steuert

Übersicht

Für dieses Beispiel habe ich einen Outrunner-BLDC-Motor mit den folgenden Spezifikationen: Er hat eine KV-Bewertung von 1000, kann mit 2S-, 3S- oder 4S-LiPo-Akkus betrieben werden und benötigt 30A ESC

Die KV-Angabe bei einem bürstenlosen Motor definiert die Drehzahl des Motors pro Volt ohne Last

In diesem Fall bedeuten die 1000KV, dass beispielsweise, wenn wir den Motor mit einem 2S-LiPo-Akku versorgen, der eine Spannung von 7,4 Volt hat, die Der Motor kann eine maximale Drehzahl von 7,4 mal 1000 erreichen, oder das sind 7400 U/min

Bürstenlose Motoren sind leistungshungrig und die gebräuchlichste Methode, sie mit Strom zu versorgen, ist die Verwendung von LiPo-Batterien

Die „S“-Nummer eines LiPo-Akkus gibt an, wie viele Zellen der Akku hat, und jede Zelle hat eine Spannung von 3,7 V

Für dieses Beispiel verwende ich einen 3S-LiPo-Akku mit 3 Zellen und das sind 11,1 V

Ich kann also davon ausgehen, dass mein Motor eine maximale Drehzahl von 11100 U / min erreicht

Schließlich ist hier ein 30-A-Regler, den ich für dieses Beispiel verwenden und mit den Motoranforderungen abgleichen werde

Auf der einen Seite hat der ESC drei Drähte, die die drei Phasen des Motors steuern, und auf der anderen Seite hat er zwei Drähte, VCC und GND, für die Stromversorgung

Es gibt auch einen weiteren Satz von drei Drähten, die aus dem ESC kommen und das ist der Signalleitung, +5V und Masse

Diese Funktion des ESC wird Battery Eliminator Circuit genannt und macht, wie der Name schon sagt, die Notwendigkeit einer separaten Batterie für einen Mikrocontroller überflüssig

Damit liefert der ESC geregelte 5 V, die zur Stromversorgung unseres Arduino verwendet werden können

Wir können hier feststellen, dass diese Verbindung tatsächlich die gleiche ist wie die, die wir bei Servomotoren sehen

Die Steuerung eines bürstenlosen Motors mit ESC und Arduino ist also so einfach wie die Steuerung des Servos mit Arduino

ESCs verwenden die gleiche Art von Steuersignal wie Servos und das ist das standardmäßige 50-Hz-PWM-Signal

Dies ist sehr praktisch, da wir beispielsweise beim Bau eines RC-Flugzeugs normalerweise sowohl Servos als auch bürstenlose Motoren benötigen und auf diese Weise steuern können sie einfach mit dem gleichen Controller-Typ

Mit dem Arduino müssen wir also nur das 50-Hz-PWM-Signal erzeugen und abhängig von der Impulsbreite oder der Dauer des hohen Zustands, die zwischen 1 Millisekunde und 2 Millisekunden variieren sollte, treibt der ESC den Motor an von minimaler bis maximaler Drehzahl.

Arduino Brushless Motor Control – Schaltplan

Hier ist der Schaltplan für dieses Beispiel

Zusätzlich zum ESC verwenden wir nur ein einfaches Potentiometer zur Steuerung der Motordrehzahl

Die für dieses Arduino-Tutorial benötigten Komponenten erhalten Sie über die folgenden Links:

Bürstenloser Motor ……………………… Amazon / Banggood / AliExpress

ESC 30A ……………………………………

Amazon / Banggood / AliExpress

Li-Po-Akku ……………….…..…… Amazon / Banggood / AliExpress

Arduino Board ………………………… Amazon / Banggood / AliExpress

Potentiometer …………………………

Amazon / Banggood / AliExpress

Steckbrett und Schaltdrähte … Amazon / Banggood / AliExpress

Offenlegung: Dies sind Affiliate-Links

Als Amazon-Partner verdiene ich an qualifizierten Käufen

Arduino-Code für BLDC-Motorsteuerung

Der Arduino-Code ist mit nur wenigen Codezeilen wirklich einfach

Servo ESC; int potValue; void setup() { ESC

anhängen (9, 1000, 2000); aufrechtzuerhalten

Leere Schleife () {potValue = analogRead (A0); potValue = map(potValue, 0 , 1023 , 0 , 180 ); ESC

schreiben (potValue); } Codesprache: Arduino ( arduino )

Beschreibung: Wir müssen also die Servo-Bibliothek definieren, da wir mit der Servo-Bibliothek problemlos das 50-Hz-PWM-Signal erzeugen können, da sonst die vom Arduino erzeugten PWM-Signale unterschiedliche Frequenzen haben

Dann müssen wir ein Servoobjekt für die ESC-Steuerung erstellen und eine Variable zum Speichern des analogen Eingangs vom Potentiometer definieren

Im Setup-Abschnitt definieren wir mit der Attach()-Funktion, an welchen Arduino-Pin das Steuersignal des ESC angeschlossen ist, und definieren auch die minimale und maximale Impulsbreite des PWM-Signals in Mikrosekunden Lesen Sie das Potentiometer, ordnen Sie seinen Wert von 0 bis 1023 einem Wert von 0 bis 180 zu

Dann senden wir mit der Funktion write () das Signal an den ESC oder erzeugen das 50-Hz-PWM-Signal

Die Werte von 0 bis 180 entsprechen den im Setup-Abschnitt definierten Werten von 1000 bis 2000 Mikrosekunden

Wenn wir also diesen Code auf unseren Arduino hochladen und dann alles mit der Batterie einschalten, können wir steuern die Drehzahl des bürstenlosen Motors mit dem Potentiometer von Null auf Maximum

Allerdings gibt es einige Dinge, die wir hier beachten sollten

Beim erstmaligen Einschalten des Motors muss der Signalwert gleich oder kleiner als der Mindestwert von 1 Millisekunde sein

Dies wird als Aktivierung des ESC bezeichnet, und der Motor gibt einen Bestätigungston ab, damit wir wissen, dass er ordnungsgemäß aktiviert ist

Falls wir beim Einschalten einen höheren Wert haben, was bedeutet, dass wir Gas geben, startet der ESC den Motor nicht, bis wir auf den korrekten Mindestwert drosseln

Dies ist in Bezug auf die Sicherheit sehr praktisch, da der Motor nicht startet, falls wir beim Einschalten Gas geben

ESC-Kalibrierung

Lassen Sie uns abschließend erklären, wie die ESC-Kalibrierung funktioniert

Jeder ESC hat seine eigenen Höhen und Tiefen, die leicht variieren können

Beispielsweise könnte der Tiefpunkt bei 1,2 Millisekunden und der Höchstpunkt bei 1,9 Millisekunden liegen

In einem solchen Fall wird unser Gashebel in den ersten 20 % nichts tun, bis er diesen Tiefpunktwert von 1,2 Millisekunden erreicht

Um dieses Problem zu lösen, können wir den ESC kalibrieren oder die Hoch- und Tiefpunkte nach Belieben einstellen

Zu diesem Zweck müssen wir vor dem Einschalten des ESC zuerst unser Potentiometer auf Maximum oder einen Wert drosseln, der mindestens größer ist als der aktuelle Mittelpunkt

Dann können wir den ESC einschalten, und wir werden ein paar Pieptöne vom Motor hören, die tatsächlich bestätigen, dass wir den neuen Höchstpunkt eingestellt haben

Dann sollten wir nach 2 Sekunden unser Potentiometer auf die Position bewegen, wo wir den neuen Tiefpunkt erreichen Punkt zu sein

Wir hören erneut die Bestätigungstöne und damit sind wir mit der ESC-Kalibrierung fertig

Jetzt reagiert unser Gashebel sofort und wir können den Motor innerhalb dieser neuen zwei Punkte steuern

Das ist so ziemlich alles für dieses Tutorial

Falls Sie lernen möchten, wie man diese bürstenlose Arduino-Motorsteuerung drahtlos macht, können Sie sich mein vorheriges Video ansehen, in dem ich einen Arduino-basierten RC-Sender baue und erklärt, wie man damit BLDC-Motoren steuert

Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben etwas gelernt Neu

Fühlen Sie sich frei, Fragen in den Kommentaren unten zu stellen, und vergessen Sie nicht, meine Sammlung von Arduino-Projekten zu überprüfen.

Types of Motors (Arduino Tutorial Series) Update

Video unten ansehen

Neue Informationen zum Thema arduino motor

In this episode we learn about the basics of DC motors, servo motors and stepper motors.

arduino motor Sie können die schönen Bilder im Thema sehen

 New Types of Motors (Arduino Tutorial Series)
Types of Motors (Arduino Tutorial Series) Update

Arduino – Motion Sensor – Servo Motor | Arduino Tutorial New Update

Learn how to use motion sensor to control servo motor. The detail instruction, code, wiring diagram, video tutorial, line-by-line code explanation are provided to help you quickly get started with Arduino. Find this and other Arduino tutorials on ArduinoGetStarted.com.

+ mehr hier sehen

Read more

Arduino – Bewegungssensor – Servomotor

Wir werden lernen:

Wenn die Bewegung erkannt wird, drehen Sie den Servomotor um 90 Grad

Wenn die Bewegung nicht erkannt wird, drehen Sie den Servomotor zurück auf 0 Grad

Über Servomotor und Bewegungssensor Wenn Sie nichts über Servomotor und Bewegungssensor wissen (Pinbelegung, wie es funktioniert, wie man programmiert. ..), erfahren Sie mehr darüber sie in den folgenden Tutorials: Arduino – Servo Motor Tutorial

Arduino – Bewegungssensor-Tutorial

Wiring Diagram Image wird mit Fritzing entwickelt

Zum Vergrößern Bild anklicken

Ersteinstellung Zeitverzögerungseinsteller Schrauben Sie ihn vollständig gegen den Uhrzeigersinn

Erfassungsbereichseinsteller Schrauben Sie ihn ganz im Uhrzeigersinn

Repeat Trigger Selector Setzen Sie den Jumper wie auf dem Bild gezeigt

Arduino Code – Motion Sensor Controls Servo Motor  # include < Servo. h> const int MOTION_SENSOR_PIN = 7; const int SERVO_PIN = 9; Servo-Servo; int-Winkel = 0; int lastMotionState; int aktueller Bewegungszustand; void setup () { Serial

beginnen (9600); PinMode (MOTION_SENSOR_PIN, INPUT); Servo

anhängen (SERVO_PIN); Servo

schreiben (Winkel); currentMotionState = digitalRead (MOTION_SENSOR_PIN); } void Schleife () {lastMotionState = aktuellerMotionState; currentMotionState = digitalRead (MOTION_SENSOR_PIN); if (currentMotionState == LOW && lastMotionState == HIGH ) { Serial

println( “Bewegung erkannt!” ); Servo

schreiben (90); } Else if (currentMotionState == HIGH && lastMotionState == LOW) { Serial

println( “Bewegung gestoppt!” ); Servo

schreiben (0); } } Quick Steps Schließen Sie Arduino über ein USB-Kabel an den PC an

Öffnen Sie die Arduino IDE, wählen Sie das richtige Board und den richtigen Port aus

Kopieren Sie den obigen Code und öffnen Sie ihn mit Arduino IDE

Klicken Sie in der Arduino IDE auf die Schaltfläche Hochladen, um den Code auf Arduino hochzuladen

Bewegen Sie Ihre Hand vor den Sensor

Siehe den Wechsel des Servomotors

Video-Tutorial Wir erwägen, Video-Tutorials zu erstellen

Wenn Sie der Meinung sind, dass die Video-Tutorials unerlässlich sind, abonnieren Sie bitte unseren YouTube-Kanal, um uns für die Erstellung der Videos zu motivieren

Das beste Arduino-Starterkit Sehen Sie sich das beste Arduino-Kit für Anfänger an

※ UNSERE NACHRICHTEN Wir sind VERFÜGBAR

Erfahren Sie, wie Sie uns mit der Erstellung Ihres Projekts beauftragen können

Wenn dieses Tutorial für Sie nützlich ist, geben Sie uns bitte die Motivation, weitere Tutorials zu erstellen

Sie können den Link dieses Tutorials überall teilen

Bitte kopieren Sie den Inhalt jedoch nicht, um ihn auf anderen Websites zu teilen

Wir haben uns viel Zeit und Mühe genommen, um den Inhalt dieses Tutorials zu erstellen, bitte respektieren Sie unsere Arbeit!

Folgen Sie uns Teilen Sie mit Ihren Freunden, um uns bei der Verbreitung des Tutorials zu helfen!

Making a DC Motor Spin | Arduino Uno Tutorial New

Video unten ansehen

Weitere hilfreiche Informationen im Thema anzeigen arduino motor

arduino motor Einige Bilder im Thema

 New Update Making a DC Motor Spin | Arduino Uno Tutorial
Making a DC Motor Spin | Arduino Uno Tutorial New

L298N Motor Driver – Arduino Interface, How It Works … New Update

08/08/2017 · Arduino and L298N Motor Driver. Now let’s make some practical applications. In the first example we will control the speed of the motor using a potentiometer and change the rotation direction using a push button. Here’s the circuit schematics. So we need an L298N motor driver, a DC motor, a potentiometer, a push button and an Arduino board. …

+ ausführliche Artikel hier sehen

Read more

In diesem Arduino-Tutorial lernen wir, wie man Gleichstrommotoren mit Arduino steuert

Wir werfen einen Blick auf einige grundlegende Techniken zur Steuerung von Gleichstrommotoren und machen zwei Beispiele, anhand derer wir lernen, wie man Gleichstrommotoren mit dem L298N-Motortreiber und dem Arduino-Board steuert

Sie können sich das folgende Video ansehen oder das unten stehende schriftliche Tutorial lesen.

Wir können die Drehzahl des Gleichstrommotors steuern, indem wir einfach die Eingangsspannung zum Motor steuern, und die gebräuchlichste Methode dafür ist die Verwendung eines PWM-Signals

PWM-DC-Motorsteuerung

PWM oder Pulsweitenmodulation ist eine Technik, die es uns ermöglicht, den Durchschnittswert der Spannung, die an das elektronische Gerät geht, durch schnelles Ein- und Ausschalten der Stromversorgung anzupassen

Die durchschnittliche Spannung hängt von der Einschaltdauer oder der Zeit ab, in der das Signal eingeschaltet ist, im Vergleich zu der Zeit, in der das Signal in einem einzigen Zeitraum ausgeschaltet ist

Abhängig von der Größe des Motors können wir also einfach einen Arduino anschließen PWM-Ausgang an die Basis eines Transistors oder das Gate eines MOSFET und steuern Sie die Drehzahl des Motors durch Steuern des PWM-Ausgangs

Das Low-Power-Arduino-PWM-Signal schaltet das Gate am MOSFET ein und aus, über das der Hochleistungsmotor angesteuert wird

Hinweis: Arduino GND und die GND der Motorstromversorgung sollten miteinander verbunden werden

Andererseits müssen wir zur Steuerung der Drehrichtung nur die Richtung des Stromflusses durch den Motor umkehren, und die gebräuchlichste Methode dafür ist die Verwendung einer H-Brücke

Eine H-Brückenschaltung enthält vier Schaltelemente, Transistoren oder MOSFETs, wobei der Motor in der Mitte eine H-ähnliche Konfiguration bildet

Durch gleichzeitiges Aktivieren von zwei bestimmten Schaltern können wir die Richtung des Stromflusses und damit die Drehrichtung des Motors ändern

Wenn wir also diese beiden Methoden, die PWM und die H-Brücke, kombinieren, können wir eine vollständige haben Kontrolle über den Gleichstrommotor

Es gibt viele DC-Motortreiber, die diese Funktionen haben, und der L298N ist einer davon

L298N-Treiber

Der L298N ist ein dualer H-Brücken-Motortreiber, der die Geschwindigkeits- und Richtungssteuerung von zwei Gleichstrommotoren gleichzeitig ermöglicht

Das Modul kann Gleichstrommotoren mit Spannungen zwischen 5 und 35 V und einem Spitzenstrom von bis zu 2 A antreiben

Schauen wir uns die Pinbelegung des L298N-Moduls genauer an und erklären, wie es funktioniert

Das Modul hat zwei Schraubklemmenblöcke für Motor A und B und einen weiteren Schraubklemmenblock für den Erdungsstift, den VCC für den Motor und einen 5-V-Stift, der entweder ein Eingang oder ein Ausgang sein kann

Dies hängt von der am verwendeten Spannung ab Motor-VCC

Das Modul verfügt über einen integrierten 5-V-Regler, der mit einem Jumper entweder aktiviert oder deaktiviert wird

See also  Best schaltplan datenbank New

Wenn die Motorversorgungsspannung bis zu 12 V beträgt, können wir den 5-V-Regler aktivieren und der 5-V-Pin kann als Ausgang verwendet werden, beispielsweise um unser Arduino-Board mit Strom zu versorgen

Wenn die Motorspannung jedoch größer als 12 V ist, müssen wir den Jumper trennen, da diese Spannungen den integrierten 5-V-Regler beschädigen

In diesem Fall wird der 5-V-Pin als Eingang verwendet, da wir ihn an eine 5-V-Stromversorgung anschließen müssen, damit der IC ordnungsgemäß funktioniert

Wir können hier feststellen, dass dieser IC einen Spannungsabfall von etwa 2 V verursacht

Wenn wir also beispielsweise eine 12-V-Stromversorgung verwenden, beträgt die Spannung an den Motorklemmen etwa 10 V, was bedeutet, dass wir nicht in der Lage sein werden, die maximale Geschwindigkeit aus unserem 12-V-Gleichstrommotor herauszuholen

Als nächstes kommen die logischen Steuereingänge

Die Pins Enable A und Enable B werden zum Aktivieren und Steuern der Drehzahl des Motors verwendet

Wenn an diesem Pin ein Jumper vorhanden ist, wird der Motor aktiviert und arbeitet mit maximaler Geschwindigkeit, und wenn wir den Jumper entfernen, können wir einen PWM-Eingang an diesen Pin anschließen und auf diese Weise die Geschwindigkeit des Motors steuern

Wenn wir diesen Pin mit Masse verbinden, wird der Motor deaktiviert.

Als nächstes werden die Pins Eingang 1 und Eingang 2 zur Steuerung der Drehrichtung des Motors A und die Eingänge 3 und 4 für den Motor B verwendet

Mit diesen Pins steuern wir tatsächlich die Schalter der H-Brücke im L298N-IC

Wenn Eingang 1 LOW und Eingang 2 HIGH ist, bewegt sich der Motor vorwärts, und umgekehrt, wenn Eingang 1 HIGH und Eingang 2 LOW ist, bewegt sich der Motor rückwärts

Falls beide Eingänge gleich sind, entweder LOW oder HIGH, stoppt der Motor

Gleiches gilt für die Eingänge 3 und 4 und den Motor B

Arduino und L298N Motor Driver

Lassen Sie uns nun einige praktische Anwendungen machen

Im ersten Beispiel steuern wir die Drehzahl des Motors mit einem Potentiometer und ändern die Drehrichtung mit einem Taster

Hier sind die Schaltpläne

Wir brauchen also einen L298N-Motortreiber, einen Gleichstrommotor, ein Potentiometer, einen Taster und ein Arduino-Board

Die für dieses Arduino-Tutorial benötigten Komponenten erhalten Sie über die folgenden Links:

L298N-Treiber ………………….

Amazon / Banggood / Aliexpress

12-V-Gleichstrommotor mit hohem Drehmoment…………..Amazon/Banggood/Aliexpress

Gleichstrommotor mit Kunststoffreifenrad ……

Amazon/Banggood/Aliexpress

Arduino-Board ………………………………Amazon/Banggood/Aliexpress

Steckbrett und Schaltdrähte …………Amazon / Banggood / Aliexpress

Offenlegung: Dies sind Affiliate-Links

Als Amazon-Partner verdiene ich an qualifizierten Käufen

Arduino-Code

Hier ist der Arduino-Code:

int rotDirection = 0 ; int gedrückt = falsch ; void setup () {pinMode (enA, AUSGANG); PinMode (in1, AUSGANG); PinMode (in2, AUSGANG); PinMode (Taste, INPUT); digitalWrite (in1, LOW); digitalWrite (in2, HIGH); aufrechtzuerhalten

void loop () { int potValue = analogRead (A0); int pwmOutput = map(potValue, 0 , 1023 , 0 , 255 ); analogWrite (enA, pwmOutput); if (digitalRead (button) == true) { Gedrückt =! Gedrückt; } while ( digitalRead (Schaltfläche) == true ); Verzögerung (20); Wenn (gedrückt == true & rotDirection == 0) {digitalWrite (in1, HIGH); digitalWrite (in2, LOW); roteRichtung = 1 ; Verzögerung (20); aufrechtzuerhalten

Wenn (gedrückt == false & rotDirection == 1) {digitalWrite (in1, LOW); digitalWrite (in2, HIGH); roteRichtung = 0 ; Verzögerung (20); } } Codesprache: Arduino ( arduino )

Beschreibung: Also müssen wir zuerst die Pins und einige Variablen definieren, die für das Programm benötigt werden

Im Setup-Bereich müssen wir die Pin-Modi und die anfängliche Drehrichtung des Motors einstellen

Im Schleifenabschnitt beginnen wir mit dem Lesen des Potentiometerwerts und ordnen dann den Wert, den wir daraus erhalten, der von 0 bis 1023 geht, einem Wert von 0 bis 255 für das PWM-Signal zu, oder das ist 0 bis 100 % Arbeitszyklus des PWM-Signal

Dann senden wir mit der Funktion analogWrite() das PWM-Signal an den Enable-Pin der L298N-Platine, die den Motor tatsächlich antreibt

Als nächstes prüfen wir, ob wir die Taste gedrückt haben, und wenn das stimmt, ändern wir die Drehrichtung des Motors, indem die Zustände von Input 1 und Input 2 umgekehrt gesetzt werden

Die Drucktaste funktioniert als Umschalttaste und jedes Mal, wenn wir sie drücken, ändert sie die Drehrichtung des Motors

Siehe auch

Wie der Servomotor funktioniert und wie man Servos mit Arduino steuert

Arduino-Roboterautosteuerung mit L298N-Motortreiber

Sobald wir das gelernt haben, können wir jetzt unser eigenes Arduino-Roboterauto bauen

Hier ist der Schaltplan:

Alles, was wir brauchen, sind 2 Gleichstrommotoren, der L298N-Motortreiber, ein Arduino-Board und ein Joystick für die Steuerung

Für die Stromversorgung habe ich mich für drei 3,7-V-Li-Ion-Akkus entschieden, die insgesamt 11 V liefern

Ich habe das Chassis aus 3 mm dickem Sperrholz gemacht, die Motoren mit Metallklammern daran befestigt, Räder an den Motoren befestigt und vorne ein Schwenkrad befestigt

Jetzt werfen wir einen Blick auf den Arduino-Code und sehen, wie es funktioniert

(Unten finden Sie den vollständigen Code)

int xAxis = analogRead (A0); int yAxis = analogRead (A1); Codesprache: Arduino ( arduino )

Nachdem wir die Pins definiert haben, beginnen wir im Schleifenabschnitt mit dem Lesen der X- und Y-Achsenwerte des Joysticks

Der Joystick besteht eigentlich aus zwei Potentiometern, die mit den analogen Eingängen des Arduino verbunden sind und Werte von 0 bis 1023 haben

Wenn der Joystick in seiner Mittelposition bleibt, liegt der Wert beider Potentiometer oder Achsen bei etwa 512

Wir werden ein wenig Toleranz hinzufügen und die Werte von 470 bis 550 als Mitte betrachten

Wenn wir also die Y-Achse des Joysticks nach hinten bewegen und der Wert unter 470 fällt, setzen wir die Drehrichtung der beiden Motoren mithilfe der vier Eingangspins auf rückwärts

Dann werden wir die fallenden Werte von 470 bis 0 in steigende PWM-Werte von 0 bis 255 umwandeln, was eigentlich die Drehzahl des Motors ist

if (yAxis < 470 ) { digitalWrite (in1, HIGH ); digitalWrite (in2, LOW); digitalWrite (in3, HIGH); digitalWrite (in4, LOW); motorSpeedA = map(yAxis, 470 , 0 , 0 , 255 ); motorSpeedB = map(yAxis, 470 , 0 , 0 , 255 ); } Codesprache: Arduino ( arduino )

Ähnlich, wenn wir die Y-Achse des Joysticks nach vorne bewegen und der Wert über 550 geht, werden wir die Motoren so einstellen, dass sie sich vorwärts bewegen und die Messwerte von 550 bis 1023 in PWM-Werte von 0 bis 255 umwandeln

Wenn der Joystick in seiner Position bleibt Mitte ist die Motorgeschwindigkeit Null

Als nächstes wollen wir sehen, wie wir die X-Achse für die linke und rechte Steuerung des Autos verwenden

if (xAxis < 470 ) { int xMapped = map (xAxis, 470 , 0 , 0 , 255 ) ; motorSpeedA = motorSpeedA - xMapped; motorSpeedB = motorSpeedB + xMapped; Wenn (MotorSpeedA <0) {MotorSpeedA = 0; aufrechtzuerhalten

Wenn (MotorSpeedB> 255) {MotorSpeedB = 255; } } Codesprache: Arduino ( arduino )

Also müssen wir zuerst die Messwerte der X-Achse in Geschwindigkeitswerte von 0 bis 255 umwandeln

Für die Bewegung nach links verwenden wir diesen Wert, um die linke Motorgeschwindigkeit zu verringern und die rechte Motorgeschwindigkeit zu erhöhen

Wegen der arithmetischen Funktionen verwenden wir hier zwei zusätzliche „if“-Anweisungen, um den Bereich der Motordrehzahl von 0 bis 255 einzuschränken

Die gleiche Methode wird verwendet, um das Auto nach rechts zu bewegen DC-Motordrehzahlregler mit dem 555-Timer-IC

Abhängig von der angelegten Spannung und dem Motor selbst kann der Motor bei niedrigeren Drehzahlen nicht in Bewegung kommen und erzeugt ein brummendes Geräusch

In meinem Fall konnten sich die Motoren nicht bewegen, wenn der Wert des PWM-Signals unter 70 lag

Verwenden Sie daher diese beiden Anweisungen, wenn ich mich tatsächlich auf den Drehzahlbereich von 70 bis 255 beschränkte

Am Ende senden wir nur die endgültigen Motordrehzahlen oder PWM-Signal an die Freigabestifte des L298N-Treibers

Wenn (motorSpeedA <70) { motorSpeedA = 0 ; aufrechtzuerhalten

Wenn (MotorSpeedB <70) {MotorSpeedB = 0; } analogWrite (enA, motorSpeedA); analogWrite (enB, motorSpeedB); Codesprache: Arduino ( arduino )

Hier ist der vollständige Code des Arduino-Roboterauto-Beispiels:

int motorSpeedA = 0 ; int motorSpeedB = 0 ; void setup () {pinMode (enA, AUSGANG); PinMode (enB, AUSGANG); PinMode (in1, AUSGANG); PinMode (in2, AUSGANG); PinMode (in3, AUSGANG); PinMode (in4, AUSGANG); aufrechtzuerhalten

Leere Schleife () {int xAxis = analogRead (A0); int yAxis = analogRead (A1); Wenn (yAxis <470) {digitalWrite (in1, HIGH); digitalWrite (in2, LOW); digitalWrite (in3, HIGH); digitalWrite (in4, LOW); motorSpeedA = map(yAxis, 470 , 0 , 0 , 255 ); motorSpeedB = map(yAxis, 470 , 0 , 0 , 255 ); } Else if (yAxis> 550) {digitalWrite (in1, LOW); digitalWrite (in2, HIGH); digitalWrite (in3, LOW); digitalWrite (in4, HIGH); motorSpeedA = map (yAchse, 550, 1023, 0, 255); motorSpeedB = map (yAchse, 550, 1023, 0, 255); aufrechtzuerhalten

sonst { motorSpeedA = 0; motorSpeedB = 0 ; } if (xAxis < 470 ) { int xMapped = map (xAxis, 470 , 0 , 0 , 255 ); motorSpeedA = motorSpeedA - xMapped; motorSpeedB = motorSpeedB + xMapped; Wenn (MotorSpeedA <0) {MotorSpeedA = 0; aufrechtzuerhalten

Wenn (MotorSpeedB> 255) {MotorSpeedB = 255; }} if (xAxis > 550) { int xMapped = map (xAxis, 550, 1023, 0, 255); motorSpeedA = motorSpeedA + xMapped; motorSpeedB = motorSpeedB – xMapped; Wenn (MotorSpeedA> 255) {MotorSpeedA = 255; aufrechtzuerhalten

Wenn (MotorSpeedB <0) {MotorSpeedB = 0; aufrechtzuerhalten

aufrechtzuerhalten

Wenn (MotorGeschwindigkeitA <70) {MotorGeschwindigkeitA = 0; aufrechtzuerhalten

Wenn (MotorSpeedB <70) {MotorSpeedB = 0; } analogWrite (enA, motorSpeedA); analogWrite (enB, motorSpeedB); } Codesprache: Arduino ( arduino )

Das wäre also alles für dieses Tutorial, und in meinem nächsten Video werden wir dieses Arduino-Roboterauto aufrüsten, indem wir Bluetooth- und Funkgeräte hinzufügen, um die Smartphone- und drahtlose Steuerung zu ermöglichen Vergessen Sie nicht, meine Sammlung von Arduino-Projekten zu überprüfen.

Hard disk motor op arduino Update New

Video unten ansehen

Neue Informationen zum Thema arduino motor

ik speel wat met oude hdd motortjes. Ik gebruik de arduino om ze aan te sturen en meet de snelheid met een sensor uit een oude muis.
Here is the code I used: http://bartvenneker.nl/schemas/Code_arduino_hdd.txt

arduino motor Ähnliche Bilder im Thema

 Update Hard disk motor op arduino
Hard disk motor op arduino Update New

How To Control a DC Motor with an Arduino – Projects New

07/07/2018 · These two digital pins of Arduino control the direction of the motor. The EN A pin of IC is connected to the PWM pin 2 of Arduino. This will control the speed of the motor. To set the values of Arduino pins 8 and 9, we will use the digitalWrite() function, and to set the value of pin 2, we will use the using analogWrite() function.

+ hier mehr lesen

Using Servo Motors with Arduino New

Video ansehen

Weitere Informationen zum Thema arduino motor

Learn to use Servo Motors with an Arduino. Directly, and with a PCA9685 I2C Servo Driver.
Accompanying article with code: https://dronebotworkshop.com/servo-motors-with-arduino/
More articles and tutorials: https://dronebotworkshop.com
Join the conversation on the forum: https://forum.dronebotworkshop.com
Subscribe to the newsletter and stay in touch: https://dronebotworkshop.com/subscribe/
Today we’ll be making things move with Servo Motors!
Analog servo motors are inexpensive little powerhouses that can be perfect when you’re designing something that needs to move. They pack a lot of torque for their size and their shaft position can be pretty accurately controlled.
We will start out by taking a look at how analog servo motors work and what kind of signal we’ll need to control them. We will also learn how to read the specs so that we can choose the best servo motor for our application.
There are two types of servo motors we will look at – conventional servos that rotate 180 or 270 degrees and continuous rotation servo motors.
Then it’s time for the experiments. We will use a couple of the example sketches written for the Arduino Servo library to show just how easy it is to control a servo motor with an Arduino.
We will also examine a method of controlling LOTS of servo motors, the PCA9685 16-channel PWM controller board. As its name would imply this board lets you control 16 devices like servo motors and it interfaces to your Arduino or Raspberry Pi using the versatile I2C bus.
And if 16 servos still isn’t enough you can cascade up to 62 of these boards to drive an unimaginable 992 servo motors with just one Arduino!
I’ll settle for a more reasonable 4 servo motors, the 4 servo motors in the MeArm that I built in an earlier video. I’ll show you how to build a controller for the MeArm using an Arduino Uno and a PCA9685 board.
Here is the Table of Contents for this video:
00:00 – Introduction
02:14 – Servo Motor Basics
07:26 – Understanding Servo Specifications
09:25 – Servo Tester Demo
14:09 – Arduino Sweep Sketch
18:56 – Arduino Knob Sketch
25:12 – The PCA9685
30:05 – MeArm Controller
As always you’ll find a detailed article on the DroneBot Workshop Website at https://dbot.ws/servo. It includes the sketches we cover in the video in an easy to download ZIP file as well as detailed explanations and links to other useful resources.
And speaking of useful resources please sign up for the DroneBot Workshop newsletter at https://dbot.ws/dbnews .
I hope you enjoy the video, and if you haven’t already please subscribe to the YouTube channel.

arduino motor Einige Bilder im Thema

 New Using Servo Motors with Arduino
Using Servo Motors with Arduino Update

Design an Arduino Based Encoder Motor using PID Controller New

03/02/2021 · Arduino Code for PID Enabled Encoder Motor Controller. The complete code used in this project can be found at the bottom of this page. After adding the required header files and source files, you should be able to directly compile the Arduino code without any errors.

+ mehr hier sehen

Read more

In der industriellen Automatisierung und Steuerung hat sich der PID-Regler zu einem der zuverlässigsten Regelalgorithmen entwickelt, der implementiert werden kann, um die Ausgangsreaktion eines beliebigen Systems zu stabilisieren

PID steht für Proportional-Integral-Differential

Diese drei Arten von Steuermechanismen werden so kombiniert, dass sie ein Fehlersignal erzeugen, und dieses Fehlersignal wird als Rückkopplung verwendet, um die Endanwendung zu steuern

PID-Regler sind in einer Vielzahl industrieller und kommerzieller Anwendungen zu finden, z

B

zur Regelung von Druck, linearer Bewegung und vielen anderen Variablen

Ein PID-Temperaturregler ist die häufigste Anwendung, die Sie im Internet finden können

Ohne einen PID-Regler kann die manuelle Ausführung der Arbeit ein mühsamer Prozess sein

Und in dieser Ära fortschrittlicher digitaler Elektronik und Mikrocontroller wurde es einfacher, einen PID-Regler in jedem System zu entwerfen und zu implementieren

Wir haben uns entschieden, einen Artikel über den PID-Regler zu schreiben, in dem wir ins Detail gehen und seine Funktionsweise verstehen Prinzip

Als nächstes nehmen wir ein Beispiel unseres Encoder-Motors und verstehen die damit verbundenen Probleme

Schließlich werden wir diese Probleme lösen, indem wir einen PID-basierten Steueralgorithmus mit unserem Lieblings-Mikrocontroller Arduino implementieren

In einem unserer vorherigen Artikel haben wir die PID-Steuerung verwendet, um einen selbstbalancierenden Roboter zu bauen Interesse an solchen Themen.

Was ist ein PID-Regler und wie funktioniert er?

Wie wir Ihnen im Einführungsabschnitt gesagt haben, ist PID ein Akronym für Proportional, Integral und Ableitung

Aber was bedeutet das überhaupt und gibt es einen einfacheren Weg, es zu verstehen? Ja da ist

Nehmen wir dafür ein Beispiel für einen intelligenten DIY-Staubsaugerroboter mit Arduino, den wir in einem unserer vorherigen Projekte gemacht haben

Für mich ist es ein sehr cooles Projekt, und es ist sehr einfach in Bezug auf Schaltung und Steuermechanismus

Sein größter Nachteil ist jedoch, dass er keinen PID-basierten Steuermechanismus aufweist

Angenommen, der Roboter reinigt sich selbst und nähert sich einer Treppe

Er hat einen Näherungssensor unter dem Roboter, der eine solche Situation erkennt und die Stromversorgung des Motors unterbricht, aber aufgrund von Trägheit stoppt der Roboter nicht sofort

Wenn das passiert, ist die Wahrscheinlichkeit hoch, dass der Roboter die Treppe hinunterstolpert

Stellen Sie sich nun vor, Sie haben ein Robocar und möchten es in einer bestimmten Position anhalten

Ohne PID kann dies sehr schwierig sein, denn wenn Sie nur die Stromversorgung unterbrechen, wird das Auto aufgrund seines Schwungs sein Ziel absolut verfehlen

Das Bild unten gibt Ihnen eine bessere Vorstellung von dem Prozess.

Jetzt, da wir das Konzept kennen, können wir weitermachen und einige der fortgeschrittenen Teile verstehen

Wenn Sie online nach einem PID-Regler suchen, erhalten Sie als erstes Ergebnis einen PID-Regler – Wikipedia, und in diesem Beitrag finden Sie ein Blockdiagramm zusammen mit einer Gleichung

Aber was bedeutet diese Gleichung überhaupt und wie implementieren wir sie in unserem Mikrocontroller? Gute Frage, folgen Sie jetzt und Sie werden verstehen, wie

Dieser Controller wird danach benannt, wie ein Fehler behandelt wird, bevor er summiert und dann an die Anlage/den Prozess gesendet wird

Lassen Sie mich erklären! Beim Integralpfad wird der Fehler mit der Konstanten Ki multipliziert, dann integriert, und beim Ableitungspfad mit Kd multipliziert und dann differenziert

Danach werden die drei Werte summiert, um die Ausgabe zu erzeugen

Jetzt werden im Controller die Parameter Kp, Kd und Ki als Verstärkung bezeichnet

Und sie werden angepasst oder abgestimmt, um einen bestimmten Satz von Anforderungen zu erfüllen, und durch Ändern dieser Werte können Sie einstellen, wie empfindlich Ihr System auf jeden dieser verschiedenen Parameter reagiert, entweder die P-, I- oder D-Parameter

Lassen Sie es mich erklären, indem ich jeden Parameter einzeln untersuche

Der P-Regler:

Nehmen wir an, der Fehler im System ändert sich im Laufe der Zeit, wie Sie in der roten Linie sehen können

Bei einem Proportionalregler ist der Ausgang der Fehler, der durch die Verstärkung Kp definiert ist

Wie Sie sehen können, erzeugt die Ausgabe eine große Ausgabe, wenn der Fehler groß ist, und wenn der Fehler null ist, ist der Ausgabefehler null, und wenn der Fehler negativ ist, ist die Ausgabe negativ

Der Ich-Controller:

Wenn sich der Fehlerwert in einem Integralregler im Laufe der Zeit ändert, beginnt das Integral, die Fehlerstarts zu summieren, und multipliziert sie mit der Konstante Ki

Bei diesem Reglertyp ist leicht zu erkennen, dass das Integralergebnis der Bereich unter der Kurve ist, wobei der blau dargestellte Bereich der positive Bereich und der gelb dargestellte Bereich der negative Bereich ist

See also  Best Choice filesharing über proxy New

In einem komplizierten System wird der Integralregler verwendet, um konstante Fehler in einem Steuersystem zu beseitigen

Unabhängig davon, wie klein der konstante Fehler ist, reicht die Summierung der Fehler letztendlich aus, um den Reglerausgang anzupassen

Im obigen Bild wird der Fehler mit der grünen Linie dargestellt

Der D-Controller:

Bei einem Differentialregler trägt die Änderungsrate des Fehlers zum Ausgangssignal bei

Wenn sich die Fehleränderung relativ langsam bewegt, können wir als Beispiel die Startposition der Sinuswelle verwenden

Die Ableitungsausgabe wird klein sein, wie Sie im obigen Bild sehen können (dargestellt durch die grüne Linie)

Und je schneller sich der Fehler ändert, desto größer wird der Ausgang

An diesem Punkt können Sie nun die drei Ausgänge summieren und Sie haben den PID-Regler

Aber oft müssen nicht alle drei Regler zusammenarbeiten, stattdessen könnten wir jeden entfernen, indem wir den Sollwert auf Null setzen

Zum Beispiel können wir einen PI-Regler haben, indem wir den D-Wert auf Null setzen, ansonsten können wir einen PD-Regler haben, indem wir den I-Parameter auf Null setzen

Jetzt, da wir eine klare Vorstellung haben, können wir zum eigentlichen Hardwarebeispiel übergehen

Was ist ein Encoder-Motor und wie funktioniert er?

Das Konzept eines Encoder-Motors ist sehr einfach: Es ist ein bürstenbehafteter Gleichstrommotor, an dem ein Encoder angebracht ist

In einem früheren Artikel haben wir ausführlich über Drehgeber gesprochen, Sie können das nachlesen, wenn Sie mehr über das Thema erfahren möchten durch Verfolgung der Drehzahl oder der Position der Motorwelle

Es gibt viele verschiedene Arten von Motoren, und alle können verschiedene Arten von Encoderkonfigurationen haben, wie z

B

inkremental oder absolut, optisch, mit Hohlwelle, magnetisch und die Liste geht weiter und weiter

Verschiedene Arten von Motoren werden für verschiedene Arten von Anwendungen hergestellt

Nicht nur Gleichstrommotoren, sondern viele Servomotoren, Schrittmotoren und Wechselstrommotoren verfügen über einen eingebauten Encoder

Im obigen Bild sehen Sie einen Encodermotor vom Typ N20 mit Permanentmagnet, der die Ausgangsdrehzahl mit Hilfe eines angeschlossenen Getriebes auf 15 reduziert

Sie können auch zwei Hallsensoren sehen, die an der Platine angebracht sind

Diese Hall-Sensoren nehmen die Drehrichtung des Motors auf, und mit Hilfe eines Mikrocontrollers können wir sie sehr einfach lesen

Erforderliche Komponenten zum Erstellen einer PID-fähigen Encoder-Motorsteuerung

An diesem Punkt haben wir eine gute Vorstellung von der Arbeit an einem PID-Regler und kennen auch unser Endziel

Basierend darauf haben wir uns entschieden, einen Arduino und einige andere ergänzende Komponenten zu verwenden, um eine Schaltung zu bauen

Eine Liste dieser ergänzenden Komponenten ist unten aufgeführt

Arduino Nano – 1

N20-Codiermotor – 1

BD139 – 2

BD140 – 2

BC548 – 2

100R-Widerstand – 2

4,7K-Widerstand – 2

Steckbrett

Überbrückungsdrähte

Energieversorgung

Schematisches Diagramm zum Testen von PID-fähigen Encoder-Motorsteuerungen

Das vollständige schematische Diagramm für die PID-fähige Encoder-Motorsteuerung ist unten dargestellt

Das Arbeitsprinzip dieser Schaltung ist sehr einfach und wird im Folgenden beschrieben.

Die Schaltung ist sehr einfach

Zuerst haben wir im Schaltplan den N20-Encoder-Motor mit sechs Pins, die Pins sind mit M1, M2 gekennzeichnet, die zur Stromversorgung des Motors verwendet werden, da dies ein sehr kleiner Motor mit einer Nennspannung von 3,3 V ist

Als nächstes haben wir die VCC- und GND-Pins, die zur Stromversorgung der Encoder-Schaltung verwendet werden

Um die Encoder-Schaltung mit Strom zu versorgen, müssen Sie ihr +5 V geben, sonst funktioniert die Encoder-Schaltung nicht richtig

Als nächstes haben wir die PIN_A und PIN_B des Motors

Diese beiden Pins sind direkt mit dem Encoder verbunden

Durch Lesen des Status dieser Stifte können wir die Drehzahl leicht messen

Dieser N20-Motor mit 15 U / min hat ein Übersetzungsverhältnis von 1: 2098, was bedeutet, dass sich die Hauptmotorwelle 2098 Mal drehen muss, damit sich die Hilfswelle einmal dreht

Die PIN_A und PIN_B sind mit Pin 9 und Pin 10 des Arduino verbunden Pin 9 und 10 sind beide PWM-fähige Pins; Die ausgewählten Pins müssen PWM-Funktionalität haben, sonst funktioniert der Code nicht

Der PID-Controller steuert den Motor, indem er die PWM steuert

Als nächstes haben wir unseren H-Brücken-Motortreiber, der Motortreiber ist so ausgelegt, dass wir den Motor steuern können, indem wir nur zwei Pins des Arduino verwenden und sogar den Motor daran hindern falsche Auslösung

Arduino-Code für PID-fähige Encoder-Motorsteuerung

Den vollständigen Code, der in diesem Projekt verwendet wird, finden Sie unten auf dieser Seite

Nachdem Sie die erforderlichen Header-Dateien und Quelldateien hinzugefügt haben, sollten Sie den Arduino-Code direkt und ohne Fehler kompilieren können

Sie können die PID-Controller-Bibliothek über den unten angegebenen Link herunterladen oder die Board-Manager-Methode verwenden, um die Bibliothek zu installieren

Die Erklärung des Codes in der ino

Datei ist wie folgt

Zuerst beginnen wir damit, alle erforderlichen Bibliotheken einzubinden

In diesem Programm verwenden wir nur die PID-Controller-Bibliothek, also müssen wir diese zuerst einbinden

Danach definieren wir alle notwendigen Pins, die erforderlich sind, um den Encoder zu lesen und den Motor anzutreiben

Sobald das erledigt ist, definieren wir alle Werte für Kp, Ki und Kd der Encoder * kommt sehr schnell, also müssen diese beiden Pins Interrupt-fähig sein * Pins */ #define ENCODER_A 2 #define ENCODER_B 3 /* die Pins MOTOR_CW und MOTOR_CCW werden verwendet, um die H-Brücke anzusteuern * die H-Brücke treibt dann die an Motoren, Diese beiden Pins müssen * PWM-fähig sein, sonst funktioniert der Code nicht

*/ #define MOTOR_CW 9 #define MOTOR_CCW 10

Als nächstes haben wir die Werte __Kp, __Ki und __Kd für unseren Code definiert

Diese drei Konstanten sind für die Einrichtung der Ausgabeantwort für unseren Code verantwortlich

Bitte beachten Sie an dieser Stelle, dass ich für dieses Projekt die Trial-and-Error-Methode verwendet habe, um die Konstanten festzulegen, aber es gibt andere Methoden, die die Arbeit sehr gut erledigen

/*In diesem Abschnitt haben wir die Verstärkung definiert Werte für den * Proportional-, Integral- und Differentialregler Ich habe die Verstärkungswerte mit Hilfe von Trial-and-Error-Methoden eingestellt *

*/ #define __Kp 260 // Proportionalkonstante #define __Ki 2.7 // Integralkonstante #define __Kd 2000 // Ableitungskonstante

Als nächstes haben wir alle notwendigen Variablen definiert, die in diesem Code benötigt werden

Zuerst haben wir die Variable encoder_count, die verwendet wird, um die Anzahl der erzeugten Interrupts zu zählen; so zählt es die Anzahl der Umdrehungen

Als nächstes haben wir eine Variable vom Typ unsigned int ganzzahlig definiert, die den Wert speichert, den wir in den seriellen Monitor eingegeben haben

Als nächstes haben wir eine Variable vom Typ char “incomingByte” definiert, die die eingehenden seriellen Daten vorübergehend speichert

Als nächstes haben wir die wichtigste Variable in diesem Code definiert, und es ist die Variable motor_pwm_value, nachdem die Daten durch den PWM-Algorithmus berechnet wurden, werden sie in dieser Variablen gespeichert

Wenn diese Variablen definiert sind, erstellen wir eine Instanz für den PID-Regler

Sobald wir dies getan haben, können wir zu unserer setup () -Funktion übergehen.

flüchtig lange int encoder_count = 0; // speichert die aktuelle Encoder-Zählung unsigned int integerValue = 0; // speichert den eingehenden seriellen Wert

Der maximale Wert ist 65535 char eingehendesByte; // analysiert und speichert jedes Zeichen einzeln int motor_pwm_value = 255; // nachdem die PID-Berechnungsdaten in dieser Variablen gespeichert wurden

PIDController pid_controller;

In der Setup-Funktion haben wir die Pins ENCODER_A und ENCODER_B als Eingang zugewiesen und wir haben die Pins MOTOR_CW und MOTOR_CCW als Ausgang definiert

Als nächstes haben wir ENCODER_A als Interrupt zugewiesen, und bei der RISING-Flanke wird dies die Funktion encoder(); Die nächsten drei Zeilen sind wieder einmal am wichtigsten, da wir den PID-Regler mit der begin()-Methode aktiviert haben und den Regler auch mit den Kp-, Ki- und Kd-Werten abgestimmt haben

Und schließlich haben wir das Limit für unseren PID-Controller-Ausgang festgelegt

Void setup () {Serial.begin (115200); // Seriell zum Debuggen PinMode (ENCODER_A, INPUT); // ENCODER_A als Eingang PinMode (ENCODER_B, INPUT); // ENCODER_B als Input PinMode (MOTOR_CW, OUTPUT); // MOTOR_CW als Ausgang pinMode (MOTOR_CCW, OUTPUT); // MOTOR_CW als Ausgang /* einen Interrupt an Pin ENCODER_A des Arduino anhängen, und wenn der Impuls in der RISING-Flanke ist, wird die Funktion encoder() aufgerufen

* / AttachInterrupt (digitalPinToInterrupt (ENCODER_A), Encoder, RISING); pidcontroller.begin(); // die PID-Instanz initialisieren pidcontroller.tune(__Kp , __Ki , __Kd); // Tune die PID, Argumente: kP, kI, kD pidcontroller.limit(-255, 255); // Begrenzen Sie den PID-Ausgang zwischen -255 und 255, dies ist wichtig, um den integralen Windup loszuwerden! }

Als nächstes haben wir unseren Abschnitt loop()

Im Schleifenabschnitt prüfen wir zunächst, ob die Seriennummer verfügbar ist oder nicht

Wenn die Seriennummer verfügbar ist, analysieren wir den Ganzzahlwert und speichern ihn in der Ganzzahlwertvariablen

Als nächstes haben wir ein ‘/n’-Zeichen, das hereinkommt

Wir fügen das in die Variable “incomingByte” ein und überprüfen diese Variable mit einer if-Anweisung, wenn sie wahr ist, fahren wir mit der Schleife fort, als nächstes setzen wir den Zielpunkt mit dem Pidcontroller. sollwert (GanzzahlWert); und geben den ganzzahligen Wert weiter, den wir gerade von serial erhalten haben

Als nächstes drucken wir den zum Debuggen empfangenen Wert aus

Wir haben die Variable motor_pwm_value und wir berechnen die PID-Werte und fügen sie in diese Variable ein

Wenn dieser Wert größer als Null ist, rufen wir die Funktion motor_ccw(motor_pwm_value) auf und übergeben den Wert, andernfalls rufen wir die Funktion motor_cw(abs(motor_pwm_value)) auf

Dies markiert das Ende unseres Schleifenabschnitts

void loop() { while (Serial.available() > 0) { integerValue = Serial.parseInt(); // speichert den integerValue incomingByte = Serial.read(); // speichert das Zeichen /n pidcontroller.setpoint(integerValue); // Das “Ziel”, das der PID-Regler zu “erreichen” versucht, Serial.println (integerValue); // den eingehenden Wert zum Debuggen ausgeben if (incomingByte == ‘

‘) // Wenn wir ein Zeilenumbruchzeichen erhalten, werden wir in der Schleife fortfahren Continue; } motor_pwm_value = pidcontroller.compute (encoder_count); // Lassen Sie die PID den Wert berechnen, gibt die berechnete optimale Ausgabe Serial.print (motor_pwm_value) zurück; // Den berechneten Wert zum Debuggen drucken Serial.print(” “); if (motor_pwm_value > 0) // Wenn der motor_pwm_value größer als Null ist, drehen wir den Motor im Uhrzeigersinn MotorCounterClockwise (motor_pwm_value); sonst // sonst bewegen wir es gegen den Uhrzeigersinn MotorClockwise (abs (motor_pwm_value)); Serial.println (encoder_count); // Drucken Sie die endgültige Encoder-Zählung

}

Als nächstes haben wir die Encoder-Funktion

Diese Funktion wird aufgerufen, wenn im ENCODER_B Interrupts mit steigender Flanke auftreten

Wenn wahr, überprüfen wir die Anweisung erneut mit if (digitalRead(ENCODER_B) == HIGH)

Sobald sie wahr ist, wird die Zählervariable inkrementiert

Andernfalls wird es dekrementiert

void encoder () { if (digitalRead (ENCODER_B) == HIGH) // wenn ENCODER_B hoch ist, erhöhen Sie die Zählung Encoder_count ++; // Zähler erhöhen sonst // sonst Zähler verringern Encoder_count–; // den Zähler verringern }

Als nächstes haben wir die Funktion, die den Motor im Uhrzeigersinn dreht

Wenn diese Funktion aufgerufen wird, prüft sie, ob der Wert größer als 100 ist oder nicht

Wenn ja, drehen wir den Motor im Uhrzeigersinn, andernfalls stoppen wir den Motor

void motor_cw (int power) { if (power > 100) { analogWrite (MOTOR_CW, power); digitalWrite (MOTOR_CCW, NIEDRIG); } // Beide Pins sind auf Low gesetzt, sonst { DigitalWrite (MOTOR_CW, LOW); digitalWrite (MOTOR_CCW, NIEDRIG); } }

Dasselbe gilt für die Funktion, die den Motor gegen den Uhrzeigersinn dreht

Wenn diese Funktion aufgerufen wird, prüfen wir den Wert und drehen den Motor gegen den Uhrzeigersinn

void motor_ccw(int power) { if (power > 100) { analogWrite(MOTOR_CCW, power); digitalWrite (MOTOR_CW, NIEDRIG); } Else { DigitalWrite (MOTOR_CW, LOW); digitalWrite (MOTOR_CCW, NIEDRIG); } }

Dies markiert das Ende unseres Codierungsabschnitts

Testen der PID-fähigen Motorsteuerung

Der folgende Aufbau wird verwendet, um die Schaltung zu testen

Wie Sie sehen können, habe ich einen Schaltkasten mit doppelseitigem Klebeband verwendet, um den Motor an Ort und Stelle zu halten, und ich habe ein kleines Abwärtswandlermodul verwendet, um den Motor mit Strom zu versorgen, da der Motor mit 3,3 V läuft

Wie Sie können Siehe auch, wir haben ein USB-Kabel mit dem Arduino verbunden, mit dem der Sollwert des PID-Reglers eingestellt wird

Wir erhalten auch die Debugging-Informationen vom Arduino mit dem USB

In diesem Fall gibt es den aktuellen Encoder-Zählwert an

Das folgende Bild gibt Ihnen eine bessere Vorstellung von dem Prozess.

Dies markiert das Ende des Tutorials

Ich hoffe, Ihnen hat der Artikel gefallen und Sie haben etwas Neues gelernt

Wenn Sie Fragen zu dem Artikel haben, können Sie diese im Kommentarbereich unten hinterlassen oder unser Elektronik-Forum nutzen

Sie können sich zum besseren Verständnis auch das Video unten auf der Seite ansehen.

Control Brushless Motor Using Arduino New

Video ansehen

Neue Informationen zum Thema arduino motor

Control your Brushless DC motor using Arduino Microcontroller and control its speed through a potentiometer.You can use this method for testing your motor without using a servo tester or transmitter.This concept can be used in Quadcopters,RC Plane and much more.For writing a code for Quadcopter You will need to insert a PID algorithm for making it more stable.
Code and Schematics-http://rztronics.com/control-brushless-motor-using-arduino/
Follow me on-
Facebook-https://www.facebook.com/RZtronics/
Instagram-https://www.instagram.com/shinedjar/
Subscribe and like if you like the video:D

arduino motor Einige Bilder im Thema

 Update Control Brushless Motor Using Arduino
Control Brushless Motor Using Arduino Update

Servo Motor Control with an Arduino – Projects New

03/06/2015 · The PWM input will be connected to one of the Arduino‘s digital output pins. Experiment 1 Hardware Required. 1 x TowerPro SG90 servo motor; 1 x Arduino Mega2560; 3 x jumper wires Wiring Diagram. The best thing about a servo motor is that it can be connected directly to an Arduino. Connect to the motor to the Arduino as shown in the table below:

+ ausführliche Artikel hier sehen

Controlling DC Motors with the L298N H Bridge and Arduino Update

Video ansehen

Weitere hilfreiche Informationen im Thema anzeigen arduino motor

In this video, I’ll show you how to use the L298N H-Bridge Motor Controller with an Arduino. Includes plans for a simple robot car.
Get more info about using the L298N at https://dronebotworkshop.com/dc-motors-l298n-h-bridge/
More articles and tutorials: https://dronebotworkshop.com
Join the conversation on the forum: https://forum.dronebotworkshop.com
Subscribe to the newsletter and stay in touch: https://dronebotworkshop.com/subscribe/
The L298N Dual H-Bridge Motor Controller is an inexpensive device that allows you to control two independent DC motors using 5-volt digital logic signals, such as the digital output pins of an Arduino. The L298N can also be used to control a single stepper motor or two sets of LED lighting strips.
In this tutorial, we’ll learn how to control two 6-volt DC motors with the L298N.
First, we will enlighten ourselves by learning a quick bit of the history of DC motors and discovering how they actually work. We will also learn what an “H-Bridge” is, how it works, and how we can control the direction of rotation of a DC motor with it.
We will then quickly discuss the concept of Pulse Width Modulation, or PWM, as it is used to control the speed of DC motors. Don’t worry, it’s a lot easier than it sounds!
Then we will look at how the L288N H-Bridge module actually works, how to hook it up to a couple of motors, and how to power it correctly.
Next, we will connect the L298N Dual H-Bridge Motor Controller to an Arduino. Once that’s done we’ll run a motor demo sketch to put the device through its paces.
After the demo, we will expand upon our sketch to allow a couple of potentiometers (connected to the Arduino’s analog inputs) to control the speed of each motor.
And now that we’ve become experts we will replace the potentiometers with a joystick and use it to control the motors. Just for fun, we’ll use this setup to build an Arduino-driven car!
The L298N Dual H-Bridge Motor Controller is a very versatile device that is sure to find a lot of use in your robotics and IoT projects. Anywhere you want to make things move with an Arduino!
This is a long video, so if you’d like to jump ahead to a specific spot here is the table of contents:
00:00 – Introduction
01:25 – What is a DC Motor \u0026 Where is it used?
03:01 – How does a DC Motor work?
04:17 – What is an H-Bridge?
05:25 – Popular L298N Interface boards
06:49 – L298N Module Pinouts and hookup
09:04 – Understanding PWM (Pulse Width Modulation)
09:58 – Testing the L298N without a controller
13:28 – Arduino Hookup to L289N
14:53 – Sketch 1 – Motor Control Demo
19:29 – Motor Control Demo
20:38 – Potentiometer Hookup to Arduino and L298N Module
21:38 – Sketch 2 – Two Potentiometer Control Demo
25:08 – Two Potentiometer Control Demo
25:43 – Joystick and Arduino Hookup
27:52 – Sketch 3 – Joystick Control Demo
34:22 – Driving our car!

For more information and other great projects and tutorials please visit https://dronebotworkshop.com/ .
And if you enjoyed this video please like it and subscribe to the DroneBot Workshop YouTube channel!

arduino motor Einige Bilder im Thema

 New Controlling DC Motors with the L298N H Bridge and Arduino
Controlling DC Motors with the L298N H Bridge and Arduino Update

Sie können weitere Informationen zum Thema anzeigen arduino motor

Updating

Schlüsselwörter zum Thema arduino motor

Updating

Danke dass Sie sich dieses Thema angesehen haben arduino motor

Articles compiled by Tratamientorosacea.com. See more articles in category: DIGITAL MARKETING

Related Videos

Leave a Comment