Arduino: Was kann man damit machen? Arduino für Anfänger: Schritt-für-Schritt-Anleitung. Arduino-Programmierung und -Projekte: Wo soll ich anfangen? Arduino-Designs

In diesem Artikel habe ich beschlossen, einen vollständigen Artikel zu sammeln Schritt für Schritt Anleitung für Arduino-Anfänger. Wir werden uns ansehen, was Arduino ist, was Sie zum Lernen benötigen, wo Sie es herunterladen und wie Sie die Programmierumgebung installieren und konfigurieren, wie sie funktioniert und wie Sie die Programmiersprache verwenden und vieles mehr, was für die Erstellung einer vollwertigen Software erforderlich ist komplexe Geräte basierend auf der Familie dieser Mikrocontroller.

Hier werde ich versuchen, ein komprimiertes Minimum anzugeben, damit Sie die Prinzipien der Arbeit mit Arduino verstehen. Für ein umfassenderes Eintauchen in die Welt der programmierbaren Mikrocontroller beachten Sie die anderen Abschnitte und Artikel dieser Website. Ich werde Links zu anderen Materialien auf dieser Website hinterlassen, um einige Aspekte detaillierter zu untersuchen.

Was ist Arduino und wozu dient es?

Arduino ist ein elektronischer Baukasten, mit dem jeder eine Vielzahl elektromechanischer Geräte erstellen kann. Arduino besteht aus Software und Hardware. Der Softwareteil umfasst eine Entwicklungsumgebung (ein Programm zum Schreiben und Debuggen von Firmware), viele vorgefertigte und praktische Bibliotheken und eine vereinfachte Programmiersprache. Die Hardware umfasst eine große Auswahl an Mikrocontrollern und vorgefertigten Modulen dafür. Dadurch ist die Arbeit mit Arduino sehr einfach!

Mit Hilfe von Arduino können Sie Programmieren, Elektrotechnik und Mechanik erlernen. Dies ist jedoch nicht nur ein pädagogischer Konstrukteur. Auf dieser Grundlage können Sie wirklich nützliche Geräte herstellen.
Angefangen von einfachen Blinklichtern, Wetterstationen, Automatisierungssystemen bis hin zu Smart-Home-Systemen, CNC-Maschinen und unbemannten Luftfahrzeugen. Den Möglichkeiten sind nicht einmal durch Ihre Fantasie Grenzen gesetzt, denn es gibt eine Vielzahl an Anleitungen und Ideen zur Umsetzung.

Arduino-Starterkit

Um mit dem Erlernen von Arduino zu beginnen, müssen Sie die Mikrocontroller-Platine selbst und zusätzliche Teile erwerben. Kaufen Sie am besten ein Arduino-Starterkit, aber Sie können alles, was Sie brauchen, selbst auswählen. Ich empfehle die Wahl eines Sets, da es einfacher und oft auch günstiger ist. Hier sind Links zu den besten Sets und Einzelteilen, die Sie unbedingt studieren müssen:

Grundlegendes Arduino-Kit für Anfänger:	Kaufen
Großes Set für Schulungen und erste Projekte:	Kaufen
Satz zusätzlicher Sensoren und Module:	Kaufen
Arduino Uno ist das einfachste und praktischste Modell aus der Reihe:	Kaufen
Lötfreies Steckbrett für einfaches Lernen und Prototyping:	Kaufen
Kabelsatz mit praktischen Anschlüssen:	Kaufen
LED-Set:	Kaufen
Widerstandsset:	Kaufen
Tasten:	Kaufen
Potentiometer:	Kaufen

Arduino IDE-Entwicklungsumgebung

Um Firmware zu schreiben, zu debuggen und herunterzuladen, müssen Sie die Arduino IDE herunterladen und installieren. Dies ist ein sehr einfaches und praktisches Programm. Auf meiner Website habe ich den Prozess des Herunterladens, Installierens und Konfigurierens der Entwicklungsumgebung bereits beschrieben. Deshalb werde ich hier nur Links hinterlassen letzte Version Programme und

Ausführung	Windows	Mac OS X	Linux
1.8.2

Arduino-Programmiersprache

Wenn Sie ein Mikrocontroller-Board in den Händen halten und eine Entwicklungsumgebung auf Ihrem Computer installiert haben, können Sie mit dem Schreiben Ihrer ersten Skizzen (Firmware) beginnen. Dazu müssen Sie sich mit der Programmiersprache vertraut machen.

Die Arduino-Programmierung verwendet eine vereinfachte Version der C++-Sprache mit vordefinierten Funktionen. Wie in anderen C-ähnlichen Programmiersprachen gibt es eine Reihe von Regeln für das Schreiben von Code. Hier sind die grundlegendsten:

• Auf jede Anweisung muss ein Semikolon (;) folgen.
• Bevor Sie eine Funktion deklarieren, müssen Sie den von der Funktion zurückgegebenen Datentyp angeben oder void, wenn die Funktion keinen Wert zurückgibt.
• Außerdem ist es notwendig, den Datentyp anzugeben, bevor eine Variable deklariert wird.
• Kommentare werden wie folgt bezeichnet: // Inline und /* Block */

Mehr über Datentypen, Funktionen, Variablen, Operatoren und Sprachkonstrukte erfahren Sie auf der Seite unter Sie müssen sich nicht alle diese Informationen merken und merken. Sie können jederzeit zum Nachschlagewerk gehen und sich die Syntax einer bestimmten Funktion ansehen.

Jede Arduino-Firmware muss mindestens 2 Funktionen enthalten. Dies sind setup() und loop().

Setup-Funktion

Damit alles funktioniert, müssen wir eine Skizze schreiben. Lassen Sie die LED nach dem Drücken der Taste aufleuchten und nach dem nächsten Drücken erlöschen. Hier ist unsere erste Skizze:

// Variablen mit Pins der angeschlossenen Geräte int switchPin = 8; int ledPin = 11; // Variablen zum Speichern des Zustands der Schaltfläche und der LED boolean lastButton = LOW; boolean currentButton = LOW; boolean ledOn = false; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); ) // Funktion zum Entprellen von boolean debounse(boolean last) ( boolean current = digitalRead(switchPin); if(last != current) ( delay ( 5); current = digitalRead(switchPin); ) Rückstrom; ) void loop() ( currentButton = debounse(lastButton); if(lastButton == LOW && currentButton == HIGH) ( ledOn = !ledOn; ) lastButton = currentButton ; digitalWrite(ledPin, ledOn); )

// Variablen mit Pins angeschlossener Geräte int switchPin = 8 ; int ledPin = 11 ; // Variablen zum Speichern des Zustands der Taste und der LED boolean lastButton = LOW ; boolean currentButton = LOW ; boolean ledOn = false ; void setup() ( pinMode(switchPin, INPUT); pinMode(ledPin, OUTPUT); // Funktion zum Entprellen boolean debounse (boolean last ) ( boolean current = digitalRead(switchPin); if (last != current ) ( Verzögerung(5); current = digitalRead(switchPin); Rückstrom; void loop() ( currentButton = debounse(lastButton); if (lastButton == LOW && currentButton == HIGH ) ( ledOn = ! ledOn; lastButton = currentButton ; digitalWrite(ledPin, ledOn);

In dieser Skizze habe ich eine zusätzliche Entprellungsfunktion erstellt, um das Abprallen von Kontakten zu unterdrücken. Auf meiner Website finden Sie Informationen zum Kontakt-Bounce. Schauen Sie sich unbedingt dieses Material an.

PWM-Arduino

Pulsweitenmodulation (PWM) ist der Prozess der Spannungssteuerung mithilfe des Tastverhältnisses eines Signals. Das heißt, mithilfe von PWM können wir die Last reibungslos steuern. Sie können beispielsweise die Helligkeit einer LED stufenlos ändern, diese Helligkeitsänderung wird jedoch nicht durch Verringern der Spannung, sondern durch Erhöhen der Intervalle des Low-Signals erreicht. Das Funktionsprinzip von PWM ist in diesem Diagramm dargestellt:

Wenn wir PWM auf die LED anwenden, beginnt sie schnell zu leuchten und zu erlöschen. Das menschliche Auge kann dies nicht erkennen, da die Frequenz zu hoch ist. Beim Aufnehmen von Videos werden Sie jedoch höchstwahrscheinlich Momente sehen, in denen die LED nicht leuchtet. Dies geschieht unter der Voraussetzung, dass die Bildrate der Kamera kein Vielfaches der PWM-Frequenz ist.

Arduino verfügt über einen eingebauten Pulsweitenmodulator. Sie können PWM nur an den Pins verwenden, die vom Mikrocontroller unterstützt werden. Arduino Uno und Nano verfügen beispielsweise über 6 PWM-Pins: Dies sind die Pins D3, D5, D6, D9, D10 und D11. Bei anderen Boards können die Pins abweichen. Hier finden Sie eine Beschreibung des Boards, an dem Sie interessiert sind

Um PWM in Arduino zu verwenden, gibt es eine Funktion. Sie verwendet als Argumente die Pin-Nummer und den PWM-Wert von 0 bis 255. 0 ist 0 % Füllung mit einem hohen Signal und 255 ist 100 %. Lassen Sie uns als Beispiel eine einfache Skizze schreiben. Lasst uns die LED sanft aufleuchten lassen, eine Sekunde warten und genauso sanft ausblenden und so weiter bis ins Unendliche. Hier ist ein Beispiel für die Verwendung dieser Funktion:

// Die LED ist an Pin 11 angeschlossen int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( for (int i = 0; i< 255; i++) { analogWrite(ledPin, i); delay(5); } delay(1000); for (int i = 255; i >0; i--) ( analogWrite(ledPin, i); delay(5); ) )

// LED an Pin 11 angeschlossen int ledPin = 11 ; void setup() ( pinMode(ledPin, OUTPUT); void loop() ( für (int i = 0 ; i< 255 ; i ++ ) { analogWrite(ledPin, i); Verzögerung(5); Verzögerung (1000); for (int i = 255; i > 0; i -- ) (

Eine Reihe von Artikeln und Trainingsdiagrammen mit Amateurfunkexperimenten auf Arduino für Anfänger. Hierbei handelt es sich um einen Amateurfunk-Spielzeugbauer, aus dem sich ohne Lötkolben, Ätzen von Leiterplatten und dergleichen aus jedem Elektronikkessel ein vollwertiges Arbeitsgerät zusammenbauen lässt, das sowohl für professionelles Prototyping als auch für Amateurexperimente im Studium der Elektronik geeignet ist .

Das Arduino-Board ist in erster Linie dazu gedacht, unerfahrenen Funkamateuren die Grundlagen der Programmierung von Mikrocontrollern und der Erstellung von Mikrocontroller-Geräten mit eigenen Händen ohne ernsthafte theoretische Ausbildung beizubringen. Mit der Arduino-Entwicklungsumgebung können Sie vorgefertigten Programmcode kompilieren und in den Board-Speicher laden. Darüber hinaus ist das Laden des Codes äußerst einfach.

Arduino, wo man als Anfänger anfangen soll

Um mit dem Arduino-Board arbeiten zu können, muss ein unerfahrener Elektronikingenieur zunächst das Arduino-Entwicklungsprogramm herunterladen. Es besteht aus einem integrierten Texteditor, in dem wir mit Programmcode arbeiten, einem Nachrichtenbereich und einem Textausgabefenster (Konsole). ), eine Symbolleiste mit Schaltflächen für häufig verwendete Befehle und mehrere Menüs. Um seine Programme herunterzuladen und zu kommunizieren, wird dieses Programm über ein Standard-USB-Kabel mit dem Arduino-Board verbunden.

In der Arduino-Umgebung geschriebener Code wird aufgerufen skizzieren. Es ist eingeschrieben Texteditor, das über spezielle Werkzeuge zum Einfügen/Ausschneiden, Ersetzen/Suchen von Text verfügt. Während des Speicherns und Exportierens werden im Nachrichtenbereich Erklärungen angezeigt (siehe Bild in der ersten Lektion für Anfänger, direkt unten) und es können auch Fehler angezeigt werden. Die Konsole zeigt Arduino-Meldungen an, einschließlich vollständiger Fehlerberichte und anderer nützlicher Informationen. Mit den Symbolleistenschaltflächen können Sie eine Skizze überprüfen und aufzeichnen, öffnen, erstellen und speichern, die serielle Busüberwachung öffnen und vieles mehr.

Kommen wir also zur ersten Lektion über Arduino-Schaltkreise für Anfänger im Elektronikbereich.

Für den Komfort von Anfängern verfügt der Arduino UNO-Controller bereits über einen Widerstand und eine LED, die an Pin 13 des Steckers angeschlossen sind, sodass wir im ersten Experiment keine externen Funkelemente benötigen.

Durch das Laden des Codes ermöglicht Arduino unserem Programm, an der Systeminitialisierung teilzunehmen. Dazu geben wir dem Mikrocontroller Befehle an, die er beim ersten Start ausführen soll, und vergessen sie dann vollständig (d. h. diese Befehle werden vom Arduino nur einmal beim Start ausgeführt). Und zu diesem Zweck wählen wir in unserem Code einen Block aus, in dem diese Befehle gespeichert sind. void setup(), bzw. im Leerraum innerhalb der geschweiften Klammern dieser Funktion, siehe Programmskizze.

Vergiss es nicht Zahnspange! Der Verlust mindestens einer davon macht die gesamte Skizze völlig unbrauchbar. Setzen Sie aber auch keine zusätzlichen Klammern, da dies ebenfalls zu einem Fehler führt.

Code herunterladen:

Skizze mit Kommentaren und Erläuterungen in der Datei 001-1_mig-led.ino

Funktion Leere Schleife() Hier geben wir die Befehle ein, die ausgeführt werden, solange das Arduino eingeschaltet ist. Nachdem die Ausführung mit dem ersten Befehl begonnen wurde, erreicht der Arduino das Ende und geht sofort zum Anfang, um die gleiche Sequenz zu wiederholen. Und so weiter, unendlich oft, solange die Platine mit Strom versorgt wird. Im Kern ist eine Void-Schleife die Hauptfunktion, der Einstiegspunkt in Arduino.

Funktion Verzögerung(1000) verzögert die Programmverarbeitung um 1000 Millisekunden. Es geht alles in einem ewigen Kreislauf weiter Schleife().

Die wichtigste Schlussfolgerung nach dem Verständnis unseres ersten Programms auf Arduino: Mithilfe der Void-Loop- und Void-Setup-Funktionen geben wir unsere Anweisungen an den Mikrocontroller weiter. Alles, was sich im Setup-Block befindet, wird nur einmal ausgeführt. Der Inhalt des Loop-Moduls wird in einer Schleife wiederholt, solange der Arduino eingeschaltet bleibt.

Im vorherigen Programm gab es eine zweite Verzögerung zwischen dem Ein- und Ausschalten der LED. Der oben verwendete einfachste Code eines unerfahrenen Arduino-Operators hatte einen großen Nachteil. Um eine Pause zwischen dem Ein- und Ausschalten der LED für eine Sekunde einzuhalten, haben wir die Funktion genutzt Verzögerung() und daher ist der Controller in diesem Moment nicht in der Lage, andere Befehle in der Hauptfunktion auszuführen Schleife(). Code in einer Funktion korrigieren Schleife(), unten vorgestellt, löst dieses Problem.

Anstatt den Wert auf HIGH und dann auf LOW zu setzen, erhalten wir den Wert von ledPin und invertieren ihn. Nehmen wir an, wenn es HOCH war, wird es NIEDRIG usw.

Zweite Arduino-Code-Option zur LED-Steuerung Hier:

Dann können Sie die Funktion ersetzen Verzögerung(). Stattdessen ist es besser, die Funktion zu verwenden millis(). Es gibt die Anzahl der Millisekunden zurück, die seit dem Programmstart vergangen sind. Nach etwa 50 Tagen der Ausführung des Programmcodes kommt es zu einem Überlauf der Funktion.

Eine ähnliche Funktion ist Mikros(), der die Anzahl der Mikrosekunden zurückgibt, die seit dem Start des Programmcodes vergangen sind. Die Funktion kehrt nach 70 Minuten Programmbetrieb auf Null zurück.

Dadurch werden unserer Skizze natürlich einige Codezeilen hinzugefügt, aber Sie werden dadurch zweifellos zu einem erfahreneren Programmierer und steigern das Potenzial Ihres Arduino. Dazu müssen Sie lediglich den Umgang mit der Millis-Funktion erlernen.

Es sollte klar sein, dass die einfachste Verzögerungsfunktion die Ausführung des gesamten Arduino-Programms anhält, sodass es in diesem Zeitraum keine Aufgaben ausführen kann. Anstatt unser gesamtes Programm anzuhalten, können wir zählen, wie viel Zeit vergeht, bis die Aktion abgeschlossen ist. Dies wird schönerweise mit der Funktion millis() implementiert. Um alles verständlicher zu machen, betrachten wir die folgende Möglichkeit, eine LED ohne Zeitverzögerung zu blinken.

Der Anfang dieses Programms ist der gleiche wie bei jeder anderen Standard-Arduino-Skizze.

In diesem Beispiel werden zwei digitale I/O-Pins von Arduino verwendet. Die LED ist an Pin 8 angeschlossen, der als OUTPUT konfiguriert ist. An 9 via ist ein Taster angeschlossen, der als INPUT konfiguriert ist. Wenn wir den Knopf drücken, wird Pin 9 auf HIGH gesetzt und das Programm schaltet Pin 8 auf HIGH und schaltet dadurch die LED ein. Durch Loslassen der Taste wird Pin 9 auf LOW zurückgesetzt. Der Code schaltet dann Pin 8 auf LOW und schaltet die Anzeigeleuchte aus.

Um fünf LEDs zu steuern, werden wir verschiedene Manipulationen mit Arduino-Ports verwenden. Dazu schreiben wir Daten direkt auf die Arduino-Ports und können so mit nur einer Funktion die Werte für die LEDs einstellen.

Arduino UNO hat drei Ports: B(digitale Ein-/Ausgänge von 8 bis 13); C(analoge Eingänge); D(digitale Ein-/Ausgänge 0 bis 7)

Jeder Port steuert drei Register. Der erste DDR gibt an, ob der Pin ein Eingang oder Ausgang sein wird. Mit dem zweiten PORT-Register können Sie den Pin auf HIGH oder LOW setzen. Mit dem dritten können Sie Informationen über den Zustand der Arduino-Beine lesen, wenn diese als Eingang dienen.

Zum Betrieb der Schaltung nutzen wir Port B. Dazu stellen wir alle Port-Pins als digitale Ausgänge ein. Port B hat nur 6 Beine. Die DDRB-Registerbits müssen auf gesetzt sein "1" , wenn der Pin als Ausgang (OUTPUT) verwendet wird, und in "0" , wenn wir planen, den Pin als Eingang (INPUT) zu verwenden. Portbits sind von 0 bis 7 nummeriert, verfügen jedoch nicht immer über alle 8 Pins

Sagen wir: DDRB = B00111110;// Setze die Pins 1 bis 5 von Port B als Ausgang und 0 als Eingang.

In unserer Lauflichtschaltung verwenden wir fünf Ausgänge: DDRB = B00011111; // Setze die Pins 0 bis 4 von Port B als Ausgänge.

Um Daten an Port B zu schreiben, müssen Sie das PORTB-Register verwenden. Mit dem Steuerbefehl können Sie die erste LED zum Leuchten bringen: PORTB = B00000001;, erste und vierte LED: PORTB = B00001001 usw

Es gibt zwei binäre Verschiebungsoperatoren: links und rechts. Der linke Schiebeoperator bewirkt, dass alle Datenbits nach links verschoben werden, während der rechte Schiebeoperator sie nach rechts verschiebt.

Beispiel:

varA = 1; // 00000001
varA = 1 varA = 1 varA = 1

Kehren wir nun zum Quellcode unseres Programms zurück. Wir müssen zwei Variablen eingeben: oben unten enthält die Werte, wohin man sich bewegen soll – nach oben oder unten, und den zweiten Zylon zeigt an, welche LEDs leuchten sollen.

Strukturell verfügt eine solche LED über einen gemeinsamen Anschluss und drei Anschlüsse für jede Farbe. Unten finden Sie ein Diagramm zum Anschluss einer RGB-LED an eine Arduino-Platine mit einer gemeinsamen Kathode. Alle im Anschlusskreis verwendeten Widerstände müssen den gleichen Wert von 220-270 Ohm haben.

Bei einer Verbindung mit einer gemeinsamen Kathode ist der Anschlussplan für eine dreifarbige LED nahezu identisch, mit der Ausnahme, dass der gemeinsame Pin nicht mit Masse (Masse am Gerät), sondern mit dem +5-Volt-Pin verbunden wird. Die Pins Rot, Grün und Blau sind jeweils mit den digitalen Ausgängen 9, 10 und 11 des Controllers verbunden.

Wir werden eine externe LED über einen Widerstand von 220 Ohm an den neunten Pin des Arduino UNO anschließen. Um dessen Helligkeit stufenlos zu steuern, nutzen Sie die Funktion analogWrite(). Es liefert ein PWM-Signal an den Controller-Zweig. Darüber hinaus das Team pinMode() Sie müssen nicht anrufen. Weil analogWrite(pin,wert) Enthält zwei Parameter: Pin – Pin-Nummer für den Ausgang, Wert – Wert von 0 bis 255.

Code:
/*
Ein Tutorial-Beispiel für einen unerfahrenen Arduino-Entwickler, das die Fähigkeiten des analogWrite()-Befehls zum Implementieren des Fade-Effekts einer LED zeigt
*/
int Helligkeit = 0; // LED-Helligkeit
int fadeAmount = 5; // Helligkeitsänderungsschritt
unsigned long currentTime;
unsigned long loopTime;

Void setup() (
pinMode(9, OUTPUT); // Pin 9 als Ausgang setzen
currentTime = millis();
loopTime = currentTime;
}

Leere Schleife() (
currentTime = millis();
if(currentTime >= (loopTime + 20))(
analogWrite(9, Helligkeit); // Den Wert auf Pin 9 setzen

Helligkeit = Helligkeit + fadeAmount; // Schritt zum Ändern der Helligkeit hinzufügen, der im nächsten Zyklus festgelegt wird

// wenn erreicht min. oder max. Werte, dann gehen wir in die entgegengesetzte Richtung (umgekehrt):
if (Helligkeit == 0 || Helligkeit == 255) (
fadeAmount = -fadeAmount ;
}
loopTime = currentTime;
}
}

Arbeiten mit Arduino mit einem Encoder

Der Encoder dient dazu, den Drehwinkel in ein elektrisches Signal umzuwandeln. Von ihm erhalten wir zwei Signale (A und B), deren Phase entgegengesetzt ist. In diesem Tutorial verwenden wir den SparkFun COM-09117-Encoder, der zwölf Positionen pro Umdrehung hat (jede Position entspricht genau 30°). Die folgende Abbildung zeigt deutlich, wie Ausgang A und B voneinander abhängen, wenn sich der Encoder im oder gegen den Uhrzeigersinn bewegt.

Wenn Signal A von einem positiven Pegel auf Null geht, lesen wir den Wert von Ausgang B. Wenn Ausgang B zu diesem Zeitpunkt in einem positiven Zustand ist, bewegt sich der Encoder im Uhrzeigersinn, wenn B einen Nullpegel ausgibt, dann Der Encoder bewegt sich in die entgegengesetzte Richtung. Durch das Auslesen beider Ausgänge können wir mithilfe eines Mikrocontrollers die Drehrichtung und durch Zählen der Impulse vom A-Ausgang des Encoders den Drehwinkel berechnen.

Bei Bedarf können Sie mithilfe von Frequenzberechnungen ermitteln, wie schnell sich der Encoder dreht.

Mithilfe eines Encoders in unserem Tutorial-Beispiel passen wir die Helligkeit der LED mithilfe des PWM-Ausgangs an. Um Daten vom Encoder auszulesen, verwenden wir eine Methode, die auf Software-Timern basiert, die wir bereits behandelt haben.

In Anbetracht der Tatsache, dass in schneller Fall, können wir den Encoderknopf in 1/10 Sekunde um 180° drehen, dann sind es 6 Impulse in 1/10 Sekunde oder 60 Impulse in einer Sekunde.

In Wirklichkeit ist es nicht möglich, schneller zu rotieren. Da wir alle Halbwellen verfolgen müssen, sollte die Frequenz etwa 120 Hertz betragen. Um ganz sicher zu gehen, nehmen wir 200 Hz.

Da wir in diesem Fall einen mechanischen Encoder verwenden, ist ein Kontaktprellen möglich, und die niedrige Frequenz filtert dieses Prellen perfekt heraus.

Basierend auf den Programm-Timer-Signalen ist es notwendig, den aktuellen Wert des Encoder-Ausgangs A ständig mit dem vorherigen Wert zu vergleichen. Ändert sich der Zustand von positiv auf Null, dann fragen wir den Status von Ausgang B ab. Abhängig vom Ergebnis der Statusabfrage erhöhen oder verringern wir den LED-Helligkeitswertzähler. Nachfolgend wird der Programmcode mit einem Zeitintervall von ca. 5 ms (200 Hz) dargestellt:

Arduino-Anfängercode:
/*
** Encoder
** Zur Steuerung der Helligkeit der LED wird ein Encoder von Sparkfun verwendet
*/

Int Helligkeit = 120; // LED-Helligkeit, beginnend mit der Hälfte
int fadeAmount = 10; // Helligkeitsänderungsschritt
unsigned long currentTime;
unsigned long loopTime;
const int pin_A = 12; // Pin 12
const int pin_B = 11; // Pin 11
unsigned char Encoder_A;
unsigned char Encoder_B;
unsigned char Encoder_A_prev=0;
void setup() (
// Pin 9 als Ausgang deklarieren:
pinMode(9, OUTPUT); // Pin 9 als Ausgang setzen
pinMode(pin_A, INPUT);
pinMode(pin_B, INPUT);
currentTime = millis();
loopTime = currentTime;
}
void loop() (
currentTime = millis();
if(currentTime >= (loopTime + 5))( // Zustände alle 5 ms prüfen (Frequenz 200 Hz)
Encoder_A = digitalRead(pin_A); // den Zustand von Ausgang A des Encoders lesen
Encoder_B = digitalRead(pin_B); // Encoder-Ausgang B
if((!encoder_A) && (encoder_A_prev))( // wenn der Zustand von positiv auf Null wechselt
if(encoder_B) (
// Ausgang B befindet sich in einem positiven Zustand, was bedeutet, dass die Drehung im Uhrzeigersinn erfolgt
// Erhöhe die Helligkeit des Glühens, nicht mehr als 255
if(brightness + fadeAmount )
anders(
// Ausgang B befindet sich im Nullzustand, was bedeutet, dass die Drehung gegen den Uhrzeigersinn erfolgt
// Helligkeit reduzieren, aber nicht unter Null
if(Brightness - fadeAmount >= 0) Brightness -= fadeAmount;
}

}
Encoder_A_prev = Encoder_A; // den Wert von A für die nächste Schleife speichern

AnalogWrite(9, Helligkeit); // Helligkeit auf den neunten Pin einstellen

LoopTime = currentTime;
}
}

In diesem Anfängerbeispiel betrachten wir die Arbeit mit einem Piezo-Emitter zur Erzeugung von Tönen. Nehmen wir dazu einen piezoelektrischen Sensor, der es uns ermöglicht, Schallwellen im Frequenzbereich 20 Hz – 20 kHz zu erzeugen.

Hierbei handelt es sich um ein Amateurfunk-Design, bei dem sich im gesamten Volumen LEDs befinden. Mit diesem Schema können Sie verschiedene Licht- und Animationseffekte erzeugen. Komplexe Diagramme können sogar verschiedene große Wörter anzeigen. Mit anderen Worten: Dies ist ein einfacher Surround-Monitor

Der Servoantrieb ist das Hauptelement bei der Konstruktion verschiedener funkgesteuerter Modelle und seine Steuerung über einen Controller ist einfach und komfortabel.

Das Steuerungsprogramm ist einfach und intuitiv. Es beginnt mit dem Anschließen einer Datei, die alle notwendigen Befehle zur Steuerung des Servoantriebs enthält. Als nächstes erstellen wir ein Servoobjekt, zum Beispiel servoMain. Die nächste Funktion ist setup(), in der wir festlegen, dass das Servo an den neunten Pin des Controllers angeschlossen wird.

Code:
/*
Arduino-Servo
*/
#enthalten
Servo-ServoMain; // Servoobjekt

Void setup()
{
servoMain.attach(9); // Servo an Pin 9 angeschlossen
}

Leere Schleife()
{
servoMain.write(45); // Servo um 45° nach links drehen
Verzögerung (2000); // 2000 Millisekunden (2 Sekunden) warten
servoMain.write(0); // Servo um 0° nach links drehen
Verzögerung (1000); // Pause 1 s.

Verzögerung (1500); // 1,5 s warten.
servoMain.write(135); // Servo um 135° nach rechts drehen
Verzögerung (3000); // Pause 3 s.
servoMain.write(180); // Servo um 180° nach rechts drehen
Verzögerung (1000); // 1 s warten.
servoMain.write(90); // Drehen Sie das Servo um 90°. Zentrale Lage
Verzögerung (5000); // Pause 5 s.
}

In der Hauptfunktion Schleife(), geben wir dem Servomotor Befehle mit Pausen dazwischen.

Arduino-Zählerschaltung auf einer 7-Segment-Anzeige

Dieses einfache Arduino-Projekt für Anfänger beinhaltet die Erstellung einer Zählerschaltung unter Verwendung einer normalen 7-Segment-Anzeige mit gemeinsamer Kathode. Mit dem folgenden Programmcode können Sie auf Knopfdruck mit dem Zählen von 0 bis 9 beginnen.

Sieben-Segment-Anzeige – ist eine Kombination aus 8 LEDs (die letzte ist für den Punkt verantwortlich) mit einer gemeinsamen Kathode, die in der gewünschten Reihenfolge eingeschaltet werden können, so dass sie Zahlen erzeugen. Zu beachten ist, dass in dieser Schaltung, siehe Abbildung unten, die Pins 3 und 8 der Kathode zugeordnet sind.

Auf der rechten Seite finden Sie eine Entsprechungstabelle zwischen Arduino-Pins und LED-Anzeigepins.

Code für dieses Projekt:

Bytezahlen = (
B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110
};
void setup() (
for(int i = 2; i pinMode(i, OUTPUT);
}
pinMode(9, INPUT);
}
int counter = 0;
bool go_by_switch = true;
int last_input_value = LOW;
void loop() (
if(go_by_switch) (
int switch_input_value = digitalRead(9);
if(last_input_value == LOW && switch_input_value == HIGH) (

}
last_input_value = switch_input_value;
) anders (
Verzögerung (500);
Zähler = (Zähler + 1) % 10;
}
writeNumber(counter);
}

Void writeNumber(int number) (
if(Nummer 9) (
zurückkehren;
}
Bytemaske = Zahlen;
Byte currentPinMask = B10000000;
for(int i = 2; i if(mask & currentPinMask) digitalWrite(i,HIGH);
sonst digitalWrite(i,LOW);
currentPinMask = currentPinMask >> 1;
}
}

Mit Hilfe zusätzlicher Module, die an die PIN-Pins nahezu aller Geräte angeschlossen werden können, können Sie das Potenzial von Arduino-Boards deutlich erweitern. Betrachten Sie die beliebtesten und interessantesten Erweiterungsmodule oder Shields, wie sie auch genannt werden.

Arduino erfreut sich bei allen Designbegeisterten großer Beliebtheit. Wer noch nie davon gehört hat, sollte es auch kennenlernen.

Was ist Arduino?

Wie kann man Arduino kurz beschreiben? Die besten Worte wären: Arduino ist ein Werkzeug, mit dem man verschiedene elektronische Geräte erstellen kann. Im Wesentlichen handelt es sich hierbei um eine echte Allzweck-Hardware-Computing-Plattform. Es kann zum Bauen verwendet werden einfache Schaltungen und für die Umsetzung recht komplexer Projekte.

Der Designer basiert auf seiner Hardware, bei der es sich um eine Eingabe-Ausgabe-Karte handelt. Zur Programmierung des Boards werden Sprachen verwendet, die auf C/C++ basieren. Sie werden jeweils als Verarbeitung/Verkabelung bezeichnet. Von der Gruppe C haben sie die extreme Einfachheit geerbt, dank derer sie von jeder Person sehr schnell erlernt werden können und die Anwendung des Wissens in der Praxis kein großes Problem darstellt. Damit Sie die Leichtigkeit der Arbeit verstehen, wird oft gesagt, dass Arduino für Anfänger-Assistenten-Designer gedacht ist. Sogar Kinder können Arduino-Boards verstehen.

Was kann man darauf sammeln?

Die Anwendungen von Arduino sind sehr vielfältig; es kann sowohl für die einfachsten Beispiele, die am Ende des Artikels empfohlen werden, als auch für recht komplexe Mechanismen verwendet werden, darunter Manipulatoren, Roboter oder Produktionsmaschinen. „Einige Handwerker schaffen es, mit solchen Systemen Tablets, Telefone, Überwachungs- und Heimsicherheitssysteme herzustellen“, Intelligentes Haus„Oder einfach nur Computer. Arduino-Projekte für Einsteiger, mit denen auch Unerfahrene loslegen können, finden Sie am Ende des Artikels. Sie können sogar zur Erstellung primitiver Virtual-Reality-Systeme verwendet werden. Alles dank der ziemlich vielseitigen Hardware und Fähigkeiten, die die Arduino-Programmierung bietet.

Wo kann ich die Komponenten kaufen?

In Italien hergestellte Komponenten gelten als Original. Der Preis solcher Kits ist jedoch nicht niedrig. Daher stellen zahlreiche Unternehmen oder sogar Einzelpersonen handwerklich Arduino-kompatible Geräte und Komponenten her, die scherzhaft als Produktionsklone bezeichnet werden. Beim Kauf solcher Klone kann man nicht mit Sicherheit sagen, dass sie funktionieren, aber der Wunsch, Geld zu sparen, fordert seinen Tribut.

Komponenten können entweder als Teil von Kits oder einzeln erworben werden. Es gibt sogar vorgefertigte Bausätze zum Zusammenbau von Autos, Hubschraubern mit unterschiedlichen Steuerungsarten oder Schiffen. Ein in China hergestelltes Set wie das oben abgebildete kostet 49 US-Dollar.

Mehr zur Ausstattung

Das Arduino-Board ist einfach AVR-Mikrocontroller, das mit einem Bootloader geflasht wurde und über den minimal erforderlichen USB-UART-Anschluss verfügt. Es gibt noch weitere wichtige Komponenten, aber im Rahmen des Artikels wäre es besser, sich nur auf diese beiden Komponenten zu konzentrieren.

Zunächst zum Mikrocontroller, einem auf einem einzigen Schaltkreis aufgebauten Mechanismus, in dem sich das entwickelte Programm befindet. Das Programm kann durch Drücken von Tasten, Empfangen von Signalen von den Komponenten der Schöpfung (Widerstände, Transistoren, Sensoren usw.) usw. beeinflusst werden. Darüber hinaus können die Sensoren in ihrem Zweck sehr unterschiedlich sein: Beleuchtung, Beschleunigung, Temperatur, Entfernung, B. Druck, Hindernisse usw. Als Anzeigegeräte können einfache Teile verwendet werden, von LEDs und Hochtönern bis hin zu komplexen Geräten, wie z. B. Grafikdisplays. Die berücksichtigten Qualitäten sind Motoren, Ventile, Relais, Servos, Elektromagnete und viele andere, deren Auflistung sehr, sehr lange dauern würde. Mit einigen dieser Listen arbeitet der MK über Verbindungsdrähte direkt zusammen. Für einige Mechanismen sind Adapter erforderlich. Aber sobald Sie mit dem Entwerfen beginnen, wird es für Sie schwierig sein, sich davon loszureißen. Lassen Sie uns nun über die Arduino-Programmierung sprechen.

Erfahren Sie mehr über den Board-Programmierungsprozess

Ein Programm, das bereits auf einem Mikrocontroller lauffähig ist, wird Firmware genannt. Es kann entweder ein Projekt oder Arduino-Projekte geben, daher wäre es ratsam, jede Firmware in einem separaten Ordner zu speichern, um den Suchvorgang zu beschleunigen notwendigen Dateien. Es wird mithilfe spezieller Geräte: Programmierern, auf den MK-Kristall geflasht. Und hier hat Arduino einen Vorteil: Es benötigt keinen Programmierer. Alles ist so gemacht, dass das Programmieren von Arduino für Anfänger nicht schwierig ist. Der geschriebene Code kann über ein USB-Kabel in den MK geladen werden. Dieser Vorteil wird nicht durch einen vorgefertigten Programmierer erreicht, sondern durch eine spezielle Firmware – einen Bootloader. Der Bootloader ist ein spezielles Programm, das sofort nach dem Anschließen startet und abhört, ob Befehle vorliegen, ob der Kristall geflasht werden soll, ob Arduino-Projekte vorhanden sind oder nicht. Die Verwendung eines Bootloaders bietet mehrere sehr attraktive Vorteile:

1. Nutzung nur eines Kommunikationskanals, was keinen zusätzlichen Zeitaufwand erfordert. Bei Arduino-Projekten müssen Sie also nicht viele verschiedene Drähte anschließen, und bei deren Verwendung kommt es zu Verwirrung. Für den erfolgreichen Betrieb reicht ein USB-Kabel.
2. Schutz vor krummen Händen. Es ist ganz einfach, den Mikrocontroller mit direkter Firmware in einen Brick-Zustand zu versetzen; Sie müssen nicht hart arbeiten. Wenn Sie mit einem Bootloader arbeiten, können Sie nicht auf potenziell gefährliche Einstellungen zugreifen (natürlich mit Hilfe eines Entwicklungsprogramms, sonst kann alles kaputt gehen). Daher ist Arduino für Anfänger nicht nur unter dem Gesichtspunkt gedacht, dass es verständlich und praktisch ist, sondern ermöglicht es Ihnen auch, unerwünschte finanzielle Ausgaben zu vermeiden, die mit der Unerfahrenheit der damit arbeitenden Person verbunden sind.

Projekte zum Einstieg

Wenn Sie einen Bausatz, einen Lötkolben, Kolophonium und Lot erworben haben, sollten Sie nicht sofort sehr komplexe Strukturen formen. Natürlich kann man sie herstellen, aber die Erfolgsaussichten in Arduino sind für Anfänger bei komplexen Projekten recht gering. Um Ihre Fähigkeiten zu trainieren und zu verbessern, können Sie versuchen, ein paar einfachere Ideen umzusetzen, die Ihnen helfen, die Interaktion und Funktionsweise von Arduino zu verstehen. Als solche ersten Schritte in der Arbeit mit Arduino für Anfänger können wir Ihnen raten, Folgendes zu berücksichtigen:

1. Erstellen Sie dank Arduino eines, das funktioniert.
2. Anschließen einer separaten Taste an Arduino. In diesem Fall können Sie festlegen, dass der Knopf das Leuchten der LED ab Punkt Nr. 1 anpassen kann.
3. Potentiometeranschluss.
4. Servoantriebssteuerung.
5. Anschließen und Arbeiten mit einer dreifarbigen LED.
6. Anschließen des piezoelektrischen Elements.
7. Anschließen eines Fotowiderstands.
8. Anschließen eines Bewegungssensors und Signalisierung seines Betriebs.
9. Anschließen eines Feuchtigkeits- oder Temperatursensors.

Projekte für die Zukunft

Es ist unwahrscheinlich, dass Sie sich für Arduino interessieren, um einzelne LEDs anzuschließen. Höchstwahrscheinlich werden Sie von der Möglichkeit angezogen, Ihr eigenes Auto oder einen fliegenden Plattenspieler zu bauen. Diese Projekte sind schwer umzusetzen und erfordern viel Zeit und Ausdauer, aber sobald sie abgeschlossen sind, erhalten Sie, was Sie wollen: wertvolle Arduino-Designerfahrung für Anfänger.

Die meisten Elektronikingenieure ziehen es vor, ihre Projekte auf Basis eines Mikrocontrollers aufzubauen, worüber wir bereits mehrfach geschrieben haben. Im folgenden Artikel befassen wir uns mit einfachen Designs elektronischer Geräte für Einsteiger und den ungewöhnlichsten Projekten auf Basis des genannten Mikrocontrollers.

Zunächst lohnt es sich, sich mit der Funktionalität des Arduino Uno-Mikroprozessors vertraut zu machen, auf dem die meisten Projekte basieren, und auch die Gründe für die Wahl dieses Geräts zu bedenken. Nachfolgend sind die Faktoren aufgeführt, warum sich ein unerfahrener Erfinder für Arduino uno entscheiden sollte:

1. Ziemlich einfach zu bedienende Oberfläche. Es ist klar, wo sich der Kontakt befindet und wo die Anschlussdrähte angebracht werden müssen.
2. Der Chip auf der Platine wird direkt mit dem USB-Anschluss verbunden. Der Vorteil dieses Aufbaus besteht darin, dass es sich bei der seriellen Kommunikation um ein sehr einfaches Protokoll handelt, das sich bewährt hat, und dass USB den Anschluss an moderne Computer sehr bequem macht.
3. Der zentrale Teil des Mikrocontrollers, der ATmega328-Chip, ist leicht zu finden. Es verfügt über weitere Hardwarefunktionen wie Timer, externe und interne Interrupts, PWM-Pins und mehrere Schlafmodi.
4. Das Gerät ist Open Source, sodass eine große Anzahl von Funkamateuren Fehler und Probleme beheben kann Software. Dies erleichtert das Debuggen von Projekten.
5. Die Taktrate beträgt 16 MHz, was für die meisten Anwendungen schnell genug ist und den Mikrocontroller nicht beschleunigt.
6. Es ist sehr praktisch, den Strom im Inneren zu steuern, und es verfügt über eine integrierte Spannungsregulierungsfunktion. Der Mikrocontroller kann auch ohne externe Stromquelle vom USB-Anschluss getrennt werden. Sie können eine externe Stromquelle bis 12 V anschließen. Darüber hinaus ermittelt der Mikroprozessor selbst die erforderliche Spannung.
7. Verfügbarkeit von 13 digitalen Kontakten und 6 analogen Kontakten. Mit diesen Pins können Sie Geräte von Drittanbietermedien an das Arduino Uno-Board anschließen. Die Pins dienen als Schlüssel zur Erweiterung der Rechenleistung des Arduino uno in der realen Welt. Schließen Sie Ihre elektronischen Geräte und Sensoren einfach an die Anschlüsse an, die jedem dieser Pins entsprechen.
8. Ein ICSP-Header ist verfügbar, um den USB-Anschluss zu umgehen und als serielles Gerät direkt mit dem Arduino zu verbinden. Dieser Port wird benötigt, um den Chip zurückzusetzen, wenn er beschädigt ist und nicht mehr auf Ihrem Computer verwendet werden kann.
9. Verfügbarkeit von 32 KB Flash-Speicher zum Speichern von Entwicklercode.
10. Die LED auf der Platine wird an den digitalen Pin 13 angeschlossen, um den Code schnell zu debuggen und den Prozess zu vereinfachen.
11. Schließlich verfügt es über eine Taste zum Zurücksetzen des Programms auf dem Chip.

Arduino wurde 2005 von zwei italienischen Ingenieuren, David Cuartilles und Massimo Banzi, mit dem Ziel entwickelt, Schülern die Programmierung des Arduino Uno-Mikrocontrollers beizubringen, ihre elektronischen Fähigkeiten zu verbessern und sie in der realen Welt einzusetzen.

Arduino Uno kann wahrnehmen Umfeld Es empfängt Eingaben von verschiedenen Sensoren und ist in der Lage, die Umgebung und andere Aktoren zu beeinflussen. Der Mikrocontroller wird mit der Programmiersprache Arduino (verdrahtungsbasiert) und der Arduino-Entwicklungsumgebung (verarbeitungsbasiert) programmiert.

Kommen wir nun direkt zu Projekten auf Arduino uno.

Das einfachste Projekt für Anfänger

Schauen wir uns ein paar einfache und interessante Arduino-Uno-Projekte an, die auch Anfänger in diesem Geschäft umsetzen können – ein Alarmsystem.

Wir haben bereits eine Lektion zu diesem Projekt gemacht -. Kurz darüber, was gemacht wird und wie.

Dieses Projekt verwendet einen Bewegungssensor zur Erkennung von Bewegungen und hochfrequenten Emissionen sowie eine visuelle Anzeige bestehend aus blinkenden LED-Lichtern. Das Projekt selbst stellt Ihnen mehrere Add-ons vor, die im Arduino Beginner Kit enthalten sind, sowie die Nuancen der Verwendung von NewPing.

Es handelt sich um eine Arduino-Bibliothek, die Ihnen hilft, Ihren Sonar-Abstandssensor zu steuern und zu testen. Obwohl es nicht gerade ein vollständiger Schutz für Ihr Zuhause ist, bietet es eine ideale Lösung zum Schutz kleiner Räume wie Schlafzimmer und Badezimmer.

Für dieses Projekt Sie wird benötigt werden:

1. Ultraschall-Ping-Sensor – HC-SR04.
2. Piezo-Summer.
3. LED-Streifen Licht.
4. Automobilbeleuchtung mit RGB-Streifen. In diesem Arduino-Projekt-Tutorial erfahren Sie, wie Sie mit einem Arduino-Uno-Board eine RGB-Innenbeleuchtung für Autos herstellen.

Viele Autoenthusiasten fügen gerne zusätzliche Lichter hinzu oder rüsten Innenbirnen auf LEDs um, aber mit der Arduino-Plattform können Sie mehr Kontrolle und Details genießen, indem Sie leistungsstarke LEDs und Lichtleisten ansteuern.

Sie können die Beleuchtungsfarbe mit ändern Android-Geräte(Telefon oder Tablet) mit der Anwendung „ Bluetooth-RGB-Controller" (Dev Next Prototypes), das Sie kostenlos herunterladen können Android Play Speichern. Sie können auch einen elektronischen EasyEDA-Schaltkreis finden oder Ihren eigenen Arduino-basierten Schaltkreis auf einer Leiterplatte bestellen.

Erstaunliche Arduino Uno-Projekte

Die meisten Profis im Bereich der Entwicklung elektronischer Projekte auf Arduino uno lieben es zu experimentieren. Dadurch entstehen interessante und überraschende Geräte, die im Folgenden besprochen werden:

1. Hinzufügen einer IR-Fernbedienung zu Ihrem Lautsprechersystem. In der Unterhaltungselektronik die Fernbedienung Fernbedienung ist eine Komponente elektronisches Gerät B. ein Fernseher, ein DVD-Player oder ein anderes Haushaltsgerät, mit dem das Gerät aus kurzer Entfernung drahtlos gesteuert werden kann. Die Fernbedienung ist vor allem für den Menschen praktisch und ermöglicht die Arbeit mit Geräten, die nicht für die direkte Bedienung der Bedienelemente geeignet sind.
2. Alarm. Zur Ermittlung der genauen Uhrzeit wird eine Echtzeituhr verwendet. Hier zeigt dieses System Datum und Uhrzeit auf dem LCD-Display an und wir können den Alarm über die Bedientasten einstellen. Sobald die Weckzeit erreicht ist, ertönt vom System ein akustisches Signal.
3. Schrittmotor. bedeutet einen präzisen Motor, der Schritt für Schritt gedreht werden kann. Ein solches Gerät wird mithilfe von Robotik, 3D-Druckern und CNC-Maschinen hergestellt.

   Besorgen Sie sich für dieses Projekt den günstigsten Schrittmotor, den Sie finden können. Motoren sind online verfügbar. Dieses Projekt verwendet einen 28byj-48-Schrittzähler, der für die meisten anderen ähnlichen Projekte geeignet ist. Der Anschluss an das Arduino-Board ist einfach.
   - Sie benötigen 6 Kabel mit Buchsen-Steckern. Sie müssen nur den Motor an die Platine anschließen und fertig! Sie können auch ein kleines Stück Klebeband am rotierenden Kopf anbringen, um zu sehen, dass er eine Drehbewegung erzeugt.

4. Ultraschall-Abstandssensor. Dieses Projekt verwendet das beliebte , sodass das Gerät Hindernissen ausweichen und sich in verschiedene Richtungen bewegen kann.

Wenn Sie Ihre Arbeit beendet haben, wird das Ergebnis Ihrer Aktionen auf dem Bildschirm angezeigt. Um die Sache einfach und übersichtlich zu halten, empfiehlt es sich, ein LCD mit I2C-Konverter zu verwenden, sodass Sie nur 4 Kabel für die Verbindung mit dem Arduino-Board benötigen.

Gehirnkurs junger Programmierkämpfer Arduino oder wo Sie anfangen können, sich mit dieser Plattform vertraut zu machen.

„Wo soll ich anfangen, Majestät? - er hat gefragt. „Beginnen Sie von vorne“, antwortete der König wichtig…“C) Lewis Carroll Alice im Wunderland

Schritt 1: Fangen wir ganz von vorne an oder wie schön wäre es, wenn Arduino kostenlos wäre

Ich habe Unmengen von Lehrbüchern darüber gelesen Arduino Nachdem wir uns eine Reihe nützlicher Anwendungen für dieses Ding im Alltag ausgedacht haben, von der Automatisierung der Fischfütterung in einem Aquarium bis hin zu einem Säroboter für einen persönlichen Rasen, verstehen wir das auch ohne Arduino wir kommen nicht durch!

Nachdem wir einen Controller gekauft haben, wissen wir, dass wir ein Board, aber viele Ideen haben. Was zu tun? Gescheit führt uns zur richtigen Entscheidung.

Arduino muss geklont werden mit seinen eigenen Händen!

Schritt 2: Sammeln Sie alles, was Sie brauchen

Um den Prozess zu beschleunigen, verwenden wir Entwicklungs-Board. Wie aus den technischen Parametern des Reglers bekannt ist ATmega 328 IC, um es in einer Minimalkonfiguration auszuführen, benötigen wir:

− Controller Arduino Duemilanove(wird als Programmierer eingesetzt);
− Mikroschaltung ATmega 328 IC ;
− 16 MHz Quarzresonator;
− Widerstände 100 Ohm 3 Stk.;
− Kondensatoren 22pF 2 Stk.;
− LEDs 3 Stück mit roten, grünen und gelben Leuchtfarben;
− 5 Volt Spannungsstabilisator, zum Beispiel 7805;
− eine beliebige 9-Batterie mit einem Anschluss zum Anschluss;
− USB-Kabel;
− Computer oder Laptop mit installiertem Softwarepaket Arduino-IDE;
− Steckbrett und Drähte.

Schritt 3: Layout starten

Wir platzieren den Controller-Chip auf dem Steckbrett.

Schritt 4: Installieren Sie den Spannungsstabilisator und die Stromkreise

Wir installieren den Spannungsstabilisator L7805 auf der Platine. Der Zweck der Mikroschaltungsstifte ist 1 Eingang (7-20 Volt), 2 Gehäuse, 3 Ausgänge (5 Volt). Mithilfe von Montagedrähten verbinden wir den Stabilisator mit der Stromquelle und dem Controller, wie auf den Fotos gezeigt.

Schritt 5: Schließen Sie den Controller an die Stromversorgung an

Entsprechend der Nummerierung der Controller-Pins verbinden wir ihn mit Montagedrähten mit dem Ausgang des Spannungsstabilisators und dem gemeinsamen Draht.

Tipp: Die Installationsdrähte haben unterschiedliche Isolationsfarben. Versuchen Sie, für jeden Stromkreis Drähte derselben Farbe zu verwenden.

Schritt 6: Schließen Sie den Quarzresonator an

Auf der Platine platzieren wir einen Resonator und Kondensatoren des Schwingkreises.

Der Installationsvorgang ist wie folgt:

− Wir platzieren einen 22pF-Kondensator zwischen Masse und dem 9. Zweig des Controllers.
− Wir platzieren einen 22pF-Kondensator zwischen Masse und dem 10. Zweig des Controllers.
− Wir schalten den Resonator zwischen den Beinen 9 und 10 des Controllers ein;
− Wir schließen einen 10-kOhm-Widerstand zwischen einem Zweig des Controllers und +5 V an (wir umgehen das „Reset“-Signal).

Schritt 7: Controller-Statusanzeigen hinzufügen

Wir verbinden die LEDs in Reihe mit 100-Ohm-Widerständen zwischen Masse und unserem Programmierer.

Schritt 7: Verbinden Sie das Steckbrett mit der Programmierplatine

Verbinden des zusammengebauten Steckbretts mit der Platine Arduino Duemilanove auf die folgende Weise:

− Verbinden Sie den Ausgang der gelben LED mit 9 Ausgang am Programmiergerät-Anschluss, sein Pulsieren zeigt uns an, dass das Programmiergerät arbeitet;
− Schließen Sie den roten LED-Ausgang an an 8 Ausgabe am Programmiereranschluss, signalisiert mögliche Fehler;
− Verbinden Sie den Ausgang der grünen LED mit 7 Der leuchtende Stift am Stecker des Programmiergeräts zeigt den Datenaustausch zwischen dem Programmiergerät und dem Mikrocontroller an.

Wir verbinden unsere Platinen mit den restlichen Drähten miteinander, wie in der Abbildung gezeigt, und vergessen nicht, die Stromkabel anzuschließen + 5 V Und rahmen zwischen ihnen.

Schritt 8: Konvertieren des Arduino Duemilanove-Boards in einen Programmierer

Zum Laden in den Mikrocontroller ATmega 328IC Der Bootloader muss in unseren umgewandelt werden Arduino Duemilanove in den Programmierer. Wir verbinden unsere Baugruppe mit dem Computer USB Kabel. Öffnen Sie die AndurinoIDE-Programmierumgebung und wählen Sie den Sketch (das Programm) darin aus AndurinoISP und lade es auf den Arduino Duemilanove hoch. Durch das Blinken der gelben LED sind wir überzeugt, dass der Sketch in unseren Programmierer geladen wurde.

Schritt 9: Laden Sie den Bootloader

In AndurinoISP (Menüpunkt « TOols") Wählen Sie den Controllertyp aus, den wir benötigen ( ATmega 328 IC). Wir geben den Befehl zum Laden des Bootloaders „Bootloader brennen“. Wir überwachen AndurinoIDE-Meldungen, nachdem der Bootloader den Ladevorgang abgeschlossen hat. „Fertig Bootloader brennen“ Unser Mikrocontroller ist bereit, eine Skizze des Projekts unseres neuen aufzuzeichnen hausgemachte Produkte.

Schritt 10: Mögliche Probleme und Lösungen

Mögliche Fehler beim Aufzeichnen eines Bootloaders und wie man diese beseitigt, zeigen die obigen Debugger-Screenshots.

Dieser Artikel erhebt keinen Anspruch auf eine vollständige Beschreibung der Programmierung. "von Grund auf neu" Mikrocontroller, zeigt aber, wie Sie mit einem minimalen Satz von Elementen beginnen können, „Ihren eigenen“ zu erstellen Andurino.