Arduino für Anfänger

// Ändern Sie die Helligkeit der LED

int ledPin = 9; // LED an diesen Pin angeschlossen
void setup () {
  pinMode (ledPin, OUTPUT); // Initialisiere den Pin für die Ausgabe
}}

void loop () {
  analogWrite (ledPin, 255); // volle Helligkeit (255/255 = 1)
  Verzögerung (1000); // Pause 1 Sek
  digitalWrite (ledPin, LOW); // LED ausschalten
  Verzögerung (1000); // Pause 1 Sek

  analogWrite (ledPin, 191); // Helligkeit bei 3/4 (191/255 ~ = 0,75)
  Verzögerung (1000); // Pause 1 Sek
  digitalWrite (ledPin, LOW); // LED ausschalten
  Verzögerung (1000); // Pause 1 Sek

  analogWrite (ledPin, 127); // halbe Helligkeit (127/255 ~ = 0,5)
  Verzögerung (1000); // Pause 1 Sek
  digitalWrite (ledPin, LOW); // LED ausschalten
  Verzögerung (1000); // Pause 1 Sek

  analogWrite (ledPin, 63); // Viertelhelligkeit (63/255 ~ = 0,25)
  Verzögerung (1000); // Pause 1 Sek
  digitalWrite (ledPin, LOW); // LED ausschalten
  Verzögerung (1000); // Pause 1 Sek
}}

analogWrite (ledPin, Helligkeit);
Verzögerung (5); // kurze Verzögerung
Helligkeit = Helligkeit + 1;

für (int Helligkeit = 0; Helligkeit = 0; Helligkeit -) {

analogWrite (ledPin, Helligkeit);
Verzögerung (5);

}}

// Ändere sanft die Helligkeit

int ledPin = 9; // LED ist an diesen Pin angeschlossen

void setup () {
  pinMode (ledPin, OUTPUT); // Initialisiere den Pin zum Beenden
}}

void loop () {
  // Erhöhe allmählich die Helligkeit (0 bis 255)
  für (int Helligkeit = 0; Helligkeit = 0; Helligkeit -) {
    analogWrite (ledPin, Helligkeit);
    Verzögerung (5);
  }}

  Verzögerung (1000); // 1 Sek. warten
 // die Helligkeit sanft verringern (255 auf 0)
  für (int Helligkeit = 255; Helligkeit> = 0; Helligkeit -) {
    analogWrite (ledPin, Helligkeit);
    Verzögerung (5);
  }}

  Verzögerung (1000); // 1 Sek. warten
}}
}}

  Skizzenmodellierung

// RGB LED - Test

// Pin-Verbindungen
int red = 9;
int grün = 10;
int blue = 11;

void setup () {
  PinMode (rot, OUTPUT);
  pinMode (blau, OUTPUT);
  pinMode (grün, OUTPUT);
}}

void loop () {
  // rote LED ein- / ausschalten
  digitalWrite (rot, HOCH);
  Verzögerung (500);
  digitalWrite (rot, NIEDRIG);
  Verzögerung (500);
  
  // grüne LED ein- / ausschalten
  digitalWrite (grün, HOCH);
  Verzögerung (500);
  digitalWrite (grün, NIEDRIG);
  Verzögerung (500);

  // schalte die blaue LED ein / aus
  digitalWrite (blau, HOCH);
  Verzögerung (500);
  digitalWrite (blau, NIEDRIG);
  Verzögerung (500);
}}

// RGB LED - zufällige Farben

// Pin-Verbindungen
int red = 9;
int grün = 10;
int blue = 11;
void setup () {
  PinMode (rot, OUTPUT);
  pinMode (blau, OUTPUT);
  pinMode (grün, OUTPUT);
}}
void loop () {
  // wähle eine zufällige Farbe
  analogWrite (rot, zufällig (256));
  analogWrite (blau, zufällig (256));
  analogWrite (grün, zufällig (256));
  delay (1000); // warte eine Sekunde
}}

int Multiplikator (int Nummer1, int Nummer2) {

int product = number1 * number2;
Produkt zurückgeben;

}} 

Knopf

In der nächsten Skizze wird eine Schaltfläche mit normalerweise geöffneten Kontakten ohne Fixierung verwendet.

Dies bedeutet, dass, während die Taste nicht gedrückt wird, der Strom nicht durch sie fließt und die Taste nach dem Loslassen in ihre ursprüngliche Position zurückkehrt.
In der Schaltung wird zusätzlich zur Taste ein Widerstand verwendet. In diesem Fall wird der Strom nicht begrenzt, sondern die Taste auf 0 V (GND) "gezogen". Das heißt, Bis der Knopf an dem Pin des Arduino gedrückt wird, an den er angeschlossen ist, ist der Pegel niedrig. Der in der 10-kΩ-Schaltung verwendete Widerstand.

// Definiere den Button Click
int buttonPin = 7;
void setup () {
  pinMode (buttonPin, INPUT); // Initialisiere den Eingangspin
  Serial.begin (9600); // Initialisiere die serielle Schnittstelle
}}
void loop () {
  if (digitalRead (buttonPin) == HIGH) {// wenn die Taste gedrückt wird
    Serial.println ("gedrückt"); // drucke "gedrückt"
  } else {
    Serial.println ("unpressed"); // sonst "unpressed"
  }}
}}

Diese Skizze enthält mehrere neue Teams.
-Dieser Befehl nimmt den Wert High (High Level) und Low (Low Level) der Ausgabe an, die wir überprüfen. Zuvor musste diese Ausgabe in setup () für die Eingabe konfiguriert werden.
;; // wobei buttonPin die PIN-Nummer ist, mit der die Taste verbunden ist.
Über die serielle Schnittstelle können Sie Arduino-Nachrichten an den Computer senden, während der Controller selbst das Programm ausführt. Dies ist nützlich zum Debuggen eines Programms und zum Senden von Nachrichten an andere Geräte oder Anwendungen. Um die Datenübertragung über die serielle Schnittstelle (auch als UART oder USART bezeichnet) zu ermöglichen, müssen Sie sie in setup () initialisieren.

Serial.begin () hat nur ein Argument ist die Datenübertragungsrate zwischen dem Arduino und dem Computer.
Skizze, ein Befehl wird verwendet, um eine Nachricht in der Arduino IDE (Tools >> Serial Monitor) anzuzeigen.
- Mit dem Design können Sie den Fortschritt des Programms steuern, indem Sie mehrere Prüfungen an einem Ort kombinieren.
Wenn (if) digitalRead HIGH zurückgibt, wird das Wort "gedrückt" auf dem Monitor angezeigt. Andernfalls wird (ansonsten) das Wort "gequetscht" auf dem Monitor angezeigt. Jetzt können Sie versuchen, die LED per Knopfdruck ein- und auszuschalten.

// Tastendruckerkennung mit LED-Ausgang
int buttonPin = 7;
int ledPin = 8;
void setup () {
  pinMode (buttonPin, INPUT); // Dieses Mal setzen wir den Button-Pin auf INPUT
  pinMode (ledPin, OUTPUT);
  Serial.begin (9600);
}}
void loop () {
  if (digitalRead (buttonPin) == HIGH) {
    digitalWrite (ledPin, HIGH);
    Serial.println ("gedrückt");
  } else {
    digitalWrite (ledPin, LOW);
    Serial.println ("unpressed");
  }}
}}

  Skizzenmodellierung

Analogeingang.

analogRead Ermöglicht das Lesen von Daten von einem der Arduino-Analogstifte und zeigt einen Wert im Bereich von 0 (0 V) bis 1023 (5 V) an. Wenn die Spannung am Analogeingang 2,5 V beträgt, wird 2,5 / 5 * 1023 = 512 gedruckt
analogRead hat nur ein Argument - Dies ist die analoge Eingangsnummer (A0-A5). Die folgende Skizze enthält einen Code zum Ablesen der Spannung von einem Potentiometer. Schließen Sie dazu einen variablen Widerstand, die extremen Pins an die Pins 5V und GND und den mittleren Pin an den Eingang A0 an.

Führen Sie den folgenden Code aus und sehen Sie im seriellen Monitor nach, wie sich die Werte abhängig von der Drehung des Widerstandsknopfs ändern.

// Analogeingang

int potPin = A0; // Der zentrale Ausgang des Potentiometers ist mit diesem Pin verbunden

void setup () {
  // Der analoge Pin ist standardmäßig durch Eingabe aktiviert, sodass keine Initialisierung erforderlich ist
  Serial.begin (9600);
}}

void loop () {
  int potVal = analogRead (potPin); // potVal ist eine Zahl zwischen 0 und 1023
  Serial.println (potVal);
}}

Die nächste Skizze kombiniert eine Skizze mit Knopfdruck und eine Skizze zur Steuerung der LED-Helligkeit. Die LED leuchtet über der Taste auf und das Potentiometer steuert die Helligkeit des Glühens.

// Tastendruckerkennung mit LED-Ausgang und variabler Intensität
int buttonPin = 7;
int ledPin = 9;
int potPin = A0;
void setup () {
  pinMode (buttonPin, INPUT);
  pinMode (ledPin, OUTPUT);
  Serial.begin (9600);
}}
void loop () {
  if (digitalRead (buttonPin) == HIGH) {// wenn die Taste gedrückt wird
    int analogVal = analogRead (potPin);
    int scaledVal = map (analogVal, 0, 1023, 0, 255);
    analogWrite (ledPin, scaledVal); // LED mit der vom Pot festgelegten Intensität einschalten
    Serial.println ("gedrückt");
  } else {
    digitalWrite (ledPin, LOW); // ausschalten, wenn die Taste nicht gedrückt wird
    Serial.println ("unpressed");
  }}
}}