In diesem Abschnitt werden wir uns die Funktionen ansehen, die für arduino-spezifische Ein- und Ausgänge verwendet werden: tone, noTone, pulseIn, pulseInLong sowie shiftIn und shiftOut.
Inhaltsübersicht
tone()
Die Funktion „tone()“ erzeugt ein Rechtecksignal mit einem Füllfaktor von 50 % an der im ersten Parameter angegebenen Abzweigung und mit der im zweiten Parameter angegebenen Frequenz.
byte pin;
unsigned int frequency;
tone(pin, frequency);Die Funktion „tone()“ wird ausgeführt, bis die Funktion „noTone()“ aufgerufen wird. Optional können wir einen dritten Parameter angeben, dies ist die Dauer, für die die Funktion „tone()“ ausgeführt werden muss.
Wenn wir den Parameter „Dauer“ (duration) angeben, wird die Ausführung unseres Sketches sofort fortgesetzt, sodass die Funktion „tone()“ die Ausführung unseres Arduino-Programms nicht blockiert, selbst wenn der Ton noch abgespielt wird.
byte pin;
unsigned int frequency;
unsigned long duration;
tone(pin, frequency, duration);An den angegebenen Pin kann beispielsweise ein Piezo-Lautsprecher angeschlossen werden, um Töne abzuspielen.
Schauen wir uns dazu eine Skizze an.
// Definieren wir die Frequenzen der Noten (Hz)
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_C5 523
// An diesen Pin wird der Summer angeschlossen
int buzzerPin = 8;
// Das Array „melody“ enthält die Noten der zu spielenden Melodie.
int melody[] = {
NOTE_C4, NOTE_C4, NOTE_D4, NOTE_C4, NOTE_F4, NOTE_E4,
NOTE_C4, NOTE_C4, NOTE_D4, NOTE_C4, NOTE_G4, NOTE_F4,
NOTE_C4, NOTE_C4, NOTE_C5, NOTE_A4, NOTE_F4, NOTE_E4, NOTE_D4,
NOTE_AS4, NOTE_AS4, NOTE_A4, NOTE_F4, NOTE_G4, NOTE_F4
};
// Die Notendauern befinden sich im Array „noteDurations“.
int noteDurations[] = {
4, 4, 4, 4, 4, 2,
4, 4, 4, 4, 4, 2,
4, 4, 4, 4, 4, 4, 2,
4, 4, 4, 4, 4, 2
};
void setup()
{
// Wir gehen die Notizen einzeln mit der for-Schleife durch
for (int thisNote = 0; thisNote < 24; thisNote++)
{
// Wir bestimmen die Spieldauer der Noten
int noteDuration = 1000 / noteDurations[thisNote];
// die Funktion tone() sendet es an den Piezo-Lautsprecher auf „buzzerPin“
// die Frequenz der aus dem „Melodie“-Array gelesenen Note,
// für die in der Variable noteDuration angegebene Zeit.
tone(buzzerPin, melody[thisNote], noteDuration);
// Wir definieren die Zeit, die zwischen dem Spielen von Noten vergeht
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// Dann stoppen wir die Ausführung der Funktion „tone()“.
noTone(buzzerPin);
}
}
void loop() {}Mit der Funktion „tone()“ kann immer nur ein Ton erzeugt werden. Wenn die Funktion „tone()“ ausgeführt wird und an einem anderen Pin aufgerufen wird, ist der zweite Funktionsaufruf erfolglos.
Wenn wir unterschiedliche Töne auf verschiedenen Pins abspielen möchten, muss noTone() aufgerufen werden, bevor tone() erneut aufgerufen wird.
Wenn wir jedoch die Funktion „tone()“ für denselben Pin, aber mit einer anderen Frequenz ausführen, legt der Aufruf seine Frequenz fest.
Die Verwendung von „tone()“ auf einigen Arduino-Boards kann den PWM-Ausgang an den Pins 3 und 11 stören.
noTone()
Die Funktion noTone() stoppt die Ausführung der Funktion tone().
noTone(pin)Wenn wir die Funktion „ tone()“ mit anderen Pins aufrufen möchten, während sie einen Ton abspielt, muss sie mit der Funktion „noTone()“ gestoppt werden, bevor die Funktion „tone()“ erneut aufgerufen wird.
Funduino UNO XXL Tanulókészlet
werbung
pulseIn()
Die Funktion „pulseIn()“ liest einen Impuls an einem Eingangspin. Der erste Parameter der Funktion ist der aktuelle Pin, von dem wir den Impuls lesen wollen. Der zweite Parameter ist die Art des zu lesenden Impulses, dieser Wert kann HIGH oder LOW sein.
Optional können wir einen dritten Timeout-Parameter angeben, der die Anzahl der Mikrosekunden angibt, bis ein Impuls gemessen wird. Wenn der Timeout-Parameter nicht angegeben ist, verwendet die Funktion „pulseIn()“ den Standardwert von 1 Sekunde.
Der Rückgabewert der Funktion ist die Länge des Impulses in Mikrosekunden oder 0, wenn innerhalb der im Timeout-Parameter angegebenen Zeit kein vollständiger Impuls empfangen wurde.
Wir können die Funktion „pulseIn()“ mit aktiven Interrupts verwenden, die Ergebnisse sind jedoch möglicherweise ungenau. Wenn Interrupts jedoch deaktiviert sind, gibt millis() einen ungenauen Wert zurück, also seien wir vorsichtig!
Die Funktion „pulseIn()“ liest kürzere Impulse zuverlässig aus, wenn wir längere Impulse messen möchten, verwenden wir stattdessen die Funktion „pulseInLong() “.
Im folgenden Beispiel ist der zweite Parameter der Funktion „pulseIn()“ HIGH. Die Funktion „pulseIn()“ wartet darauf, dass der Pin von Low auf High wechselt, startet den Timer, wartet dann darauf, dass der Pin wieder auf Low geht, stoppt den Timer und übergibt die Impulslänge in Mikrosekunden (oder 0) an die „period“. Variable.
int pulsePin = 6;
unsigned long period;
void setup()
{
Serial.begin(115200);
pinMode(pulsePin, INPUT);
}
void loop()
{
noInterrupts();
period = pulseIn(pulsePin, HIGH);
interrupts();
Serial.println(period);
}pulseInLong()
Die Funktion „pulseInLong()“ ist eine Alternative zu „pulseIn()“, die längere Impulse besser verarbeitet.
Die Funktion „pulseInLong()“ kann zum Messen von Impulsen zwischen 10 Mikrosekunden und 3 Minuten verwendet werden und kann nur verwendet werden, wenn Interrupts aktiviert sind!
Bei kürzeren Pulsen ist es fehleranfällig, in diesem Fall verwenden wir stattdessen die Funktion pulseIn().
int pulsePin = 6;
unsigned long period;
void setup()
{
Serial.begin(115200);
pinMode(pulsePin, INPUT);
}
void loop()
{
period = pulseInLong(pulsePin, HIGH);
Serial.println(period);
}Der Arduino Mega 2560 Mikrocontroller-Board
shiftIn()
Die Funktion „shiftIn()“ liest ein Datenbyte Stück für Stück und gibt den Wert des gelesenen Bytes zurück. Der Lesevorgang beginnt mit dem höchstwertigen (MSBFIRST) oder niedrigstwertigen (LSBFIRST) Bit. Die Funktion „shiftIn()“ zieht den ClockPin für jedes Bit auf High, liest das nächste Bit von der Datenleitung und setzt den ClockPin dann wieder auf Low.
Die Arduino-Funktionen „shiftIn()“ und „shiftOut()“ sind Software-Implementierungen von SPI. Natürlich ist SPI viel schneller, aber SPI kann nur auf einigen speziellen Pins auf dem Arduino funktionieren, während ShiftIn() und ShiftOut() zwei beliebige Pins auf dem Arduino verwenden können.
byte incomingByte;
int dataPin = 2;
int clockPin = 3;
int bitOrder = MSBFIRST;
void setup()
{
Serial.begin(115200);
pinMode(dataPin, INPUT);
pinMode(clockPin, OUTPUT);
}
void loop()
{
incomingByte = shiftIn(dataPin, clockPin, bitOrder);
Serial.println(incomingByte);
delay(1000);
}Die Funktion „shiftIn()“ hat drei Parameter. „dataPin“ ist die Nummer des Pins, an dem wir Daten vom angeschlossenen Gerät lesen.
„clockPin“ ist die Nummer des Pins, der das Taktsignal bereitstellt.
Der Parameter „bitOrder“ definiert die Reihenfolge, in der die Bits verschoben werden sollen. MSBFIRST oder LSBFIRST.
Wenn wir von einem Gerät lesen möchten, dessen Taktsignal mit steigenden Flanken arbeitet, muss der ClockPin vor dem Aufruf der Funktion „shiftIn()“ auf Low gezogen werden.
byte incomingByte;
int dataPin = 2;
int clockPin = 3;
int bitOrder = MSBFIRST;
void setup()
{
Serial.begin(115200);
pinMode(dataPin, INPUT);
pinMode(clockPin, OUTPUT);
}
void loop()
{
digitalWrite(clockPin, LOW);
incomingByte = shiftIn(dataPin, clockPin, bitOrder);
Serial.println(incomingByte);
delay(1000);
}shiftOut()
Die Funktion „shiftOut()“ verschiebt (sendet) ein Datenbyte um einen angegebenen Pin. Die Funktion „shiftOut()“ hat keinen Rückgabewert. Das Verschieben (Senden) des Bytes beginnt mit dem höchstwertigen (MSBFIRST) oder niedrigstwertigen (LSBFIRST) Bit. Die Funktion „shiftOut()“ zieht den ClockPin für jedes Bit auf High, verschiebt das nächste Bit und setzt den ClockPin dann wieder auf Low.
int dataPin = 2;
int clockPin = 3;
int bitOrder = MSBFIRST;
byte value = 10010111;
void setup()
{
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
shiftOut(dataPin, clockPin, bitOrder, value);
}
void loop(){}
Die Funktion „shiftOut()“ hat vier Parameter. Der „dataPin“ ist der Pin, an den jedes Bit geschoben werden soll.
„clockPin“ gibt das Taktsignal aus. Es geht hoch und dann niedrig, wenn das Bit am Pin „dataPin“ verfügbar ist.
Die Variable „bitOrder“ definiert die Reihenfolge, in der die Bits verschoben werden sollen. MSBFIRST oder LSBFIRST.
Die Variable „value“ enthält den Wert des zu verschiebenden Bytes.
Wenn wir Daten an ein Gerät senden, dessen Taktsignal mit steigenden Flanken arbeitet, muss der ClockPin auf Low gezogen werden, bevor die Funktion „shiftOut()“ aufgerufen wird.
int dataPin = 2;
int clockPin = 3;
int bitOrder = MSBFIRST;
byte value = 10010111;
void setup()
{
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
digitalWrite(clockPin, LOW);
shiftOut(dataPin, clockPin, bitOrder, value);
}
void loop(){}
Soll ein Wert größer als 8 Bit an den Ausgang ausgegeben werden (d. h. der Wert ist größer als 255), muss die Operation in mehreren Schritten durchgeführt werden.
// Der Wert ist größer als 255
int value = 500;
// Daher senden wir zwei Bytes.
// Wenn die Bitreihenfolge MSBFIRST ist, gehen wir wie folgt vor
shiftOut(dataPin, clockPin, MSBFIRST, (value >> 8));
shiftOut(dataPin, clockPin, MSBFIRST, value);
// Oder wenn die Bitreihenfolge LSBFIRST ist, gehen wir wie folgt vor
shiftOut(dataPin, clockPin, LSBFIRST, value);
shiftOut(dataPin, clockPin, LSBFIRST, (value >> 8));Im folgenden Beispiel verbinden wir einen 74HC595-Schieberegister-IC mit dem Arduino UNO und steuern 8 parallele LEDs mit nur 3 Arduino-Pins.
Für die Schaltung verwendete Dinge:
Erstellen wir die folgende Schaltung:
Der zugehörige Arduino-Skizze.
int latchPin = 8; // Arduino 8 pin --> 74HC595 ST_CP pin
int clockPin = 12; // Arduino 12 pin --> 74HC595 SH_CP pin
int dataPin = 11; // Arduino 11 pin --> 74HC595 DS pin
void setup()
{
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop()
{
for (int i = 0; i < 256; i++)
{
// Der latchPin bleibt so lange niedrig, wie die Datenübertragung läuft.
// Dadurch wird der Inhalt des Speicherregisters an den Ausgangsstiften deaktiviert.
digitalWrite(latchPin, LOW);
// Die Funktion shiftOut() sendet das aktuelle Bit an das Schieberegister 74HC595
shiftOut(dataPin, clockPin, LSBFIRST, i);
// Das Ziehen des Latch-Pins nach oben zeigt dem 74HC595-Chip an, dass die Übertragung abgeschlossen ist.
// und die gesendeten Bits können vom Speicherregister zu den Ausgängen übertragen werden.
digitalWrite(latchPin, HIGH);
// und warten wir dann eine Sekunde, um die Änderung der Ausgabe zu sehen.
delay(1000);
}
}