#PiezoBuzzer

[draegerit]

Arduino Plug and Make Kit: Abstandskontrolle mit Alarmfunktion

In diesem Beitrag erfährst du Schritt-für-Schritt, wie man eine Abstandskontrolle mit Alarmfunktion mit dem Arduino Plug and Make Kit aufbaut und programmiert. Das neue Arduino Plug and Make Kit habe ich dir bereits im gleichnamigen Beitrag Arduino Plug and Make Kit: Was ist drin und wie benutzt man es? vorgestellt. https://youtu.be/YL-enMuAMBc Das Arduino Plug and Make Kit bekommst du derzeit für knapp 90€ inkl. Versandkosten im offiziellen Shop. Aus diesem Kit verwenden wir den Arduino UNO R4 WiFi, den Laser Distanzsensor, den Piezo Buzzer, das 8fach LED Modul sowie den Rotary Encoder. Zusätzlich benötigen wir noch die Modulino Base, ein paar Schrauben & Muttern sowie die Qwiic Anschlusskabel. Das alles ist im Kit enthalten, du benötigst quasis nurnoch deinen PC und einen kleinen Kreuzschraubendreher.

Arduino UNO R4 WiFi

ToF - Distance Sensor

Buzzer

8fach LED Modul

Rotary Encoder

Wie soll das kleine Projekt funktionieren?

Über den Distanzsensor messen wir dauerhaft einen Abstand zu einem Gegenstand (Wand, Türrahmen etc.) wenn dieser Wert unterschritten wird, dann wird ein Alarm (akustisch und visuell) ausgegeben. Über den Rotary Encoder und der 8x12 LED Matrix vom Arduino UNO R4 WiFi stellen wir den Abstand ein. Dabei wird, wenn wir eine Klick-Aktion am Rotary Encoder ausführen, der aktuelle Wert auf der Matrix ausgegeben.

Benötigte Ressourcen für den Aufbau

Für den Aufbau der Schaltung benötigst du: - einen Arduino UNO R4 WiFi, - ein USB-C Datenkabel, - ein ToF / Laser Distanzsensor, - ein Rotary Encoder, - ein 8fach LED Modul, - ein Piezo Buzzer, sowie - ein paar Schrauben und - einen kleinen Kreuzschraubendreher

Arduino Plug and Make Kit - Komponenten für das Alarmprojekt Ausgenommen vom Kreuzschraubendreher ist alles im Arduino Plug and Make Kit enthalten!

Programmieren der Modulino Sensoren / Aktoren in der Ardino IDE

Das Kit ist ausgelegt, um in der Arduino IDE programmiert zu werden. Du musst jedoch zuvor den Boardtreiber für den Arduino UNO R4 WiFi und die Bibliothek für die Modulino Sensoren / Aktoren installieren.

Zu der Bibliothek Modulino erhältst du zu jedem Sensor / Aktor aus diesem Kit ein ausführliches Beispiel und in der offiziellen Dokumentation nochmal viel mehr Informationen. Programm - Durchgangsalarm mit dem Arduino Plug and Make KitHerunterladen Schritt 1 - Importieren der Bibliotheken und erzeugen der Objektinstanzen Im ersten Schritt importieren wir die benötigten Bibliotheken für das Projekt. (Zur Vorbereitung hatten wir bereits die Modulino Bibliothek installiert.) //Bibliothek zum steuern / auslesen //der Modulino Sensoren / Aktoren #include //Bibliotheken zum steuern der //8x12 LED Matrix am Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" Anschließend erzeugen wir uns die Objektinstanzen für unser Projekt. //Objektinstanz der LED-Matrix ArduinoLEDMatrix matrix; //Objektinstanzen der Sensoren / Aktoren ModulinoDistance distance; ModulinoPixels leds; ModulinoKnob knob; ModulinoBuzzer buzzer; Schritt 2 - Initialisieren der Kommunikation mit den Sensoren / Aktoren Nachdem die benötigten Bibliotheken installiert und die Objekte erzeugt wurden, müssen wir die I2C Kommunikation starten. Dazu müssen wir bei den Modulinos lediglich die Funktion "begin" aufrufen. Dieses macht die verwendung dieser Module sehr einfach und komfortabel. void setup() { //beginn der seriellen Kommunikation Serial.begin(9600); //beginn der Kommunikation mit der LED-Matrix matrix.begin(); //Vorbereiten der Kommunikation mit den Modulino //Sensoren / Aktoren Modulino.begin(); //Initialisieren der I2C Kommunikation mit den //Sensoren / Aktoren distance.begin(); leds.begin(); knob.begin(); buzzer.begin(); //Startwert des Rotary Encoders / Knob auf 0 setzen. knob.set(0); } Zusätzlich setze ich den Wert des Rotary Encoders auf 0. Schritt 3 - Auslesen der Sensorwerte und erzeugen des Alarms Im dritten Schritt lesen wir in der Funktion "loop" zunächst den Wert des Rotary Encoders aus und multiplizieren diesen mit 10. Damit müssen wir nicht so viele Umdrehungen machen damit ein Abstand eingestellt werden kann, wenn du kleine Schritte benötigst dann musst du diesen Wert anpassen. //lesen des aktuellen Wertes vom Rotary Encoder //der Wert wird mit 10 multipliziert und abgespeichert int16_t distanceForAlarm = knob.get() * 10; Wenn der Rotary Encoder gedrückt wird, können wir eine zusätzliche Aktion ausführen, in diesem Fall wird der Wert auf der 8x12 LED Matrix angezeigt. //Wenn der Rotary Encoder gedrückt wird, dann... if (knob.isPressed()) { //Aufrufen der Funktion zum Anzeigen des aktuellen //wertes des Rotary Encoder. displayKnobValue(distanceForAlarm); } Wenn der Distanzsensor erkannt wurde, dann lesen wir einen Messwert und vergleichen diesen mit dem eingestellten Abstand vom Rotary Encoder. if (distance.available()) { //Messwert abrufen und abspeichern int measure = distance.get(); //Wenn der messwert kleiner als der abgespeicherte //Wert für den Alarm ist, dann... if (measure < distanceForAlarm) { //Ausgeben des Textes "Alarm" auf der seriellen Schnittstelle Serial.println("Alarm"); //anzeigen eines visuellen Alarms über das 8fach LED Modul visualAlarm(); //ausgeben eines akustischen Alarms über das Piezo Buzzer Modul soundAlarm(); } } Am Ende legen wir noch eine kleine Pause von 20 Millisekunden ein. //eine kleine Pause von 20 ms. delay(20); Schritt 3.1 - Funktion "displayKnobValue" Die Funktion displayKnobValue zeigt den Wert des Übergebenen Parameters auf der 8x12 LED Matrix an. Sollte jedoch der Wert kleiner 0 sein, so wird eine Fehlermeldung angezeigt. /Funktion zum anzeigen eines Textes auf der //LED-Matrix. void displayKnobValue(int16_t value) { matrix.beginDraw(); matrix.stroke(0xFFFFFFFF); matrix.textScrollSpeed(50); String message = "-undefined- "; //Wenn der Wert kleiner 0 ist, dann... if (value < 0) { //erzeugen einer kleinen Fehlermeldung message = "err: val < 0"; } else { //Wenn der wert größer 0 ist, dann müssen wir //eine 12 Zeichen lange Zeichenkette erzeugen. int valueLength = String(value).length(); int partLength = (12 - valueLength) / 2; String part = ""; for (int s = 0; s < partLength; s++) { part += " "; } message = part + String(value) + part; } //ablegen der erstellten Zeichenkette in das Char-Array char text = ""; message.toCharArray(text, 13); //Ausgeben des Textes auf der LED-Matrix //Schriftgröße 4x6 matrix.textFont(Font_4x6); matrix.beginText(0, 1, 0xFFFFFF); matrix.println(text); matrix.endText(SCROLL_LEFT); matrix.endDraw(); } Schritt 3.2 - Funktion "visualAlarm" Die Funktion visualAlarm lässt die LEDs im 25ms. Intervall aufleuchten. //Funktion zum erzeugen eines visuellen Alarms mit //dem 8fach LED Modul. Die LEDs blinken im 25ms. Takt void visualAlarm() { setLEDsStatus(true); delay(25); setLEDsStatus(false); delay(25); } //Funktion zum setzen der LEDs. //Als Parameter wird der erwartete Status übergeben. void setLEDsStatus(bool on) { //Schleife über die LEDs for (int i = 0; i < 8; i++) { //Wenn die LEDs aktiviert werden sollen, dann ist //die Helligkeit auf 100 ansonsten auf 0 leds.set(i, RED, on ? 100 : 0); } //nachdem alle LEDs konfiguriert wurden, dann werden //diese Daten ausgeliefert / angezeigt. leds.show(); } Schritt 3.3 - Funktion "soundAlarm" Mit der Funktion soundAlarm wird der Piezo Buzzer angesteuert und dieser erzeugt einen hellen Ton als zusätzlichen Signal. //Funktion zum erzeugen eines Tones auf //dem Piezo Buzzer Moduls. void soundAlarm() { //die Frequenz des Tones int frequency = 440; //die Dauer int duration = 1000; //erzeugen des Tones buzzer.tone(frequency, duration); delay(50); //abschalten des Tones buzzer.tone(0, duration); delay(25); } Fertiges Projekt - Durchgangsalarm mit dem Arduino Plug and Make Kit Hier nun das fertige Projekt zum kopieren. //Bibliothek zum steuern / auslesen //der Modulino Sensoren / Aktoren #include //Bibliotheken zum steuern der //8x12 LED Matrix am Arduino UNO R4 WiFi #include "ArduinoGraphics.h" #include "Arduino_LED_Matrix.h" //Objektinstanz der LED-Matrix ArduinoLEDMatrix matrix; //Objektinstanzen der Sensoren / Aktoren ModulinoDistance distance; ModulinoPixels leds; ModulinoKnob knob; ModulinoBuzzer buzzer; void setup() { //beginn der seriellen Kommunikation Serial.begin(9600); //beginn der Kommunikation mit der LED-Matrix matrix.begin(); //Vorbereiten der Kommunikation mit den Modulino //Sensoren / Aktoren Modulino.begin(); //Initialisieren der I2C Kommunikation mit den //Sensoren / Aktoren distance.begin(); leds.begin(); knob.begin(); buzzer.begin(); //Startwert des Rotary Encoders / Knob auf 0 setzen. knob.set(0); } void loop() { //lesen des aktuellen Wertes vom Rotary Encoder //der Wert wird mit 10 multipliziert und abgespeichert int16_t distanceForAlarm = knob.get() * 10; //Wenn der Rotary Encoder gedrückt wird, dann... if (knob.isPressed()) { //Aufrufen der Funktion zum Anzeigen des aktuellen //wertes des Rotary Encoder. displayKnobValue(distanceForAlarm); } //Wenn ein ToF Sensor verfügbar ist, dann... if (distance.available()) { //Messwert abrufen und abspeichern int measure = distance.get(); //Wenn der messwert kleiner als der abgespeicherte //Wert für den Alarm ist, dann... if (measure < distanceForAlarm) { //Ausgeben des Textes "Alarm" auf der seriellen Schnittstelle Serial.println("Alarm"); //anzeigen eines visuellen Alarms über das 8fach LED Modul visualAlarm(); //ausgeben eines akustischen Alarms über das Piezo Buzzer Modul soundAlarm(); } } //eine kleine Pause von 20 ms. delay(20); } //Funktion zum anzeigen eines Textes auf der //LED-Matrix. void displayKnobValue(int16_t value) { matrix.beginDraw(); matrix.stroke(0xFFFFFFFF); matrix.textScrollSpeed(50); String message = "-undefined- "; //Wenn der Wert kleiner 0 ist, dann... if (value < 0) { //erzeugen einer kleinen Fehlermeldung message = "err: val < 0"; } else { //Wenn der wert größer 0 ist, dann müssen wir //eine 12 Zeichen lange Zeichenkette erzeugen. int valueLength = String(value).length(); int partLength = (12 - valueLength) / 2; String part = ""; for (int s = 0; s < partLength; s++) { part += " "; } message = part + String(value) + part; } //ablegen der erstellten Zeichenkette in das Char-Array char text = ""; message.toCharArray(text, 13); //Ausgeben des Textes auf der LED-Matrix //Schriftgröße 4x6 matrix.textFont(Font_4x6); matrix.beginText(0, 1, 0xFFFFFF); matrix.println(text); matrix.endText(SCROLL_LEFT); matrix.endDraw(); } //Funktion zum erzeugen eines visuellen Alarms mit //dem 8fach LED Modul. Die LEDs blinken im 25ms. Takt void visualAlarm() { setLEDsStatus(true); delay(25); setLEDsStatus(false); delay(25); } //Funktion zum erzeugen eines Tones auf //dem Piezo Buzzer Moduls. void soundAlarm() { //die Frequenz des Tones int frequency = 440; //die Dauer int duration = 1000; //erzeugen des Tones buzzer.tone(frequency, duration); delay(50); //abschalten des Tones buzzer.tone(0, duration); delay(25); } //Funktion zum setzen der LEDs. //Als Parameter wird der erwartete Status übergeben. void setLEDsStatus(bool on) { //Schleife über die LEDs for (int i = 0; i < 8; i++) { //Wenn die LEDs aktiviert werden sollen, dann ist //die Helligkeit auf 100 ansonsten auf 0 leds.set(i, RED, on ? 100 : 0); } //nachdem alle LEDs konfiguriert wurden, dann werden //diese Daten ausgeliefert / angezeigt. leds.show(); } Read the full article

[rajendra314]

ELECTROMAGNETIC PIEZO BUZZER 5V & 12V

STOCK AVAILABLE !!!

FOR PRICE AND MORE INFORMATION FOLLOW US ON OUR WHATSAPP CHANNEL :

For any Query:

☎ : +91-9899391155, +91-9910772484

Know More: https://www.indiamart.com/rajendra-electronics-newdelhi/

Facebook: https://www.facebook.com/profile.php?id=61550818087962

Instagram: https://www.instagram.com/rajendra.electronic/

LinkedIn: https://www.linkedin.com/in/rajendra-electronics-144b73290/

Reddit: https://www.reddit.com/user/Rajendra_Electronics

Youtube: https://www.youtube.com/@Rajendra_Electronics/about

Twitter: https://twitter.com/Rajendra_Elec

Pinterest: https://in.pinterest.com/rajendraelectronics314/

Tumblr: https://www.tumblr.com/blog/rajendra314

#buzzingdeals #piezobuzzersale #saveonbuzzers #buzzerblowout #TechSale #buzzerbonanza #SaleAlert #GadgetDeals #discountbuzzer #ElectronicsSale #buzzersavings #buzzerdiscount #salebuzz #SmartSavings #piezopowersale #soundsavings #buzzandsave #upto45off #techdiscounts #shopandsave #SoundInnovation #piezoperfection #buzzeralert #piezobuzz #TinyTech #buzztech #SmartSound #piezoperformance #buzzingtech #techsound #piezopros

[ouke-components]

Micro Buzzer 5vOUKE factory 5v active buzzer 5v piezo buzzer mini buzzer 5v Arduino active passive buzzer small buzzer micro buzzer.Good 5v buzzer price with good quality!http://www.globalouke.com/buzzer/micro-buzzer-5v.html #smallbuzzer #microbuzzer #piezobuzzer #5vbuzzer #buzzerfactory #beeper #chinabuzzer #electroniccomponents OUKEEmail:okay@cn-okay.comPWhatApp/WeChat:(86)13968779124

[naturalinteraction2084155-blog]

Aan het project werken in het weekend

Gezien het lastig wordt alles mee naar huis te slapen zonder direct wat los of kapot te maken kan ik het apparaatje gelukkig op afstand aan zetten vanuit slaapstand en deze via teamviewer besturen. Hierdoor kan ik code uploaden en functionaliteiten zoals de piezobuzzer en meer testen via een console log. Voor mensen die ineens een robot zien bewegen erg raar maar dit zorgt ervoor dat ik in het weekend door kan werken aan de code zonder kans op het beschadigen van ons project.  

[pferrerf-blog]

Piezo Buzzer connected to a photocell reading.

Led connected to a photocell too_ activatingspace

CODE

int speakerPin = 11;

int ledPin = 12;

int photocellPin1 = 0;

int photocellPin2 = 1;

  void setup()

{

  pinMode(ledPin,OUTPUT);

}

  void loop()

{

  // SOUND //

  int reading1 = analogRead(photocellPin1);

  int pitch = 200 + reading1 / 4;

  tone(speakerPin, pitch);

     // LIGHT //

 // int brightness = map(reading, 0,1023,0,255);

 //  digitalWrite(ledPin, 255-brightness);

  int reading2 = analogRead(photocellPin2);

  if (reading2 <  825){

     digitalWrite(ledPin, HIGH);

     delay (50);

     digitalWrite(ledPin, LOW);

     delay (50);

     digitalWrite(ledPin, HIGH);

     delay (50);

     digitalWrite(ledPin, LOW);

     delay (50);

                                }

    else {

    digitalWrite (ledPin, LOW);

  }

   }

[draegerit]

MicroPython mit ESP32: Töne erzeugen mit dem Piezo Buzzer

In diesem Beitrag möchte ich dir jetzt zeigen, wie du Töne und sogar ganze Lieder mit einem Piezo Buzzer am ESP32 mit MicroPython erzeugen kannst. https://youtu.be/2GHp5eZNJOg Im Beitrag MicroPython mit ESP32: Helligkeitsregelung von LEDs mit PWM hatte ich dir bereits gezeigt, wie du PWM Signale erstellen kannst, um die Helligkeit einer LED zu regeln. Für das Erzeugen eines Tones benötigen wir ebenfalls ein PWM Signal, in diesem Fall regeln wir damit die Frequenz des Tones. Auf meinem Blog hatte ich dir bereits einen ähnlichen Beitrag in der Vergangenheit zu diesem Thema unter Programmieren mit MicroPython #5: Piezo Buzzer am ESP32 betreiben veröffentlicht, hier möchte ich jedoch passend zum Rich Shield von Open Smart speziell auf dieses eingehen.

Schaltung - Piezo Buzzer am ESP32 D1 R32

Für diese Beitragsreihe verwende ich wie bereits erwähnt das Rich Shield von Open Smart. Auf diesem ist ein Piezo Buzzer verbaut, welcher wie folgt, mit dem Mikrocontroller verbunden ist: BauteilESP32 D1 R32Arduino UNO R3Piezo BuzzerIO25D4

Rich Shield von Open Smart auf dem ESP32 D1 R32

Schaltung ohne Rich Shield von Open Smart

Wenn du das genannte Shield nicht hast, dann kannst du dir recht einfach diese kleine Schaltung selber nachbauen. - einen ESP32 D1 R32* - einen Piezo Buzzer* - ein 170 Pin Breadboard* - zwei Breadboardkabel*, männlich-männlich

Schaltung - Piezo Buzzer am ESP32 D1 R32 Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Erzeugen eines Tones am Piezo Buzzer mit MicroPython

Der kleine Piezo Buzzer nutzt die Spannung vom GPIO und somit benötigst du keine zusätzliche Stromquelle. Das macht die Schaltung einfach, jedoch ist dieser dadurch auch nicht besonders laut. Für kleine Spielereien am Mikrocontroller sind diese jedoch ideal! from machine import Pin, PWM # Importiere die notwendigen Module Pin und PWM aus der machine-Bibliothek import time # Importiere das time-Modul für Zeitsteuerungsfunktionen # Initialisiere den Piezo Buzzer auf Pin 25 mit einer Frequenz von 440 Hz und einem Duty Cycle von 50% (512 von 1024) beeper = PWM(Pin(25), freq=440, duty=512) # Lasse den Ton für 0,5 Sekunden erklingen time.sleep(0.5) # Deinitialisiere den PWM-Kanal, um den Ton zu stoppen beeper.deinit() Erklärung der einzelnen Codezeilen: - from machine import Pin, PWM: - Diese Zeile importiert die Pin und PWM Klassen aus dem machine Modul. Pin wird verwendet, um die GPIO-Pins zu konfigurieren, und PWM wird verwendet, um PWM-Signale zu erzeugen. - import time: - Das time Modul wird importiert, um Verzögerungen einzufügen. - beeper = PWM(Pin(25), freq=440, duty=512): - Pin(25): Initialisiert den GPIO-Pin 25 als PWM-Ausgang. - freq=440: Setzt die PWM-Frequenz auf 440 Hz, was der Frequenz des Tons A entspricht (auch bekannt als der Kammerton A). - duty=512: Setzt den Duty Cycle auf 512, was 50 % der maximalen Duty Cycle (0 …1023) entspricht. Dies bedeutet, dass das Signal gleichmäßig zwischen an und aus wechselt. - time.sleep(0.5): - Wartet 0,5 Sekunden, während der Piezo Buzzer den Ton mit der eingestellten Frequenz und Duty Cycle ausgibt. - beeper.deinit(): - Deinitialisiert den PWM-Kanal, wodurch der Ton gestoppt wird. Der PWM-Ausgang wird deaktiviert und der GPIO-Pin wird in seinen ursprünglichen Zustand zurückversetzt. Dieser einfache Code erzeugt einen Ton mit einer Frequenz von 440 Hz (A4) für eine halbe Sekunde über einen Piezo Buzzer, der an GPIO-Pin 25 des ESP32 angeschlossen ist.

Regeln der Frequenz mit dem Drehpotentiometer

Im Beitrag MicroPython mit ESP32: Einführung in analoge Sensoren habe ich dir erläutert wie du einen Drehpotentiometer auslesen kannst, mit diesem analogen Bauteil kannst du auch die Frequenz anpassen. In dem Code habe ich eine zusätzliche Funktion implementiert welche den Wertebereich des analogen Sensors (Drehpotentiometer) auf einen Frequenzbereich mappt. # Funktion zum Mappen der analogen Werte des Drehpotentiometers (0..1023) # auf eine Frequenz von 200 Hz bis 1500 Hz def map_value(x, in_min=0, in_max=1023, out_min=200, out_max=1500): return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min Wenn du die Frequenz erhöhen möchtest dann kannst du die Parameter out_min & out_max entweder in der Funktion anpassen oder du gibst diese als namedparameter beim aurufen der Funktion mit. # Module zum Zugriff auf die GPIOs from machine import Pin, ADC, PWM # Modul zum Zugriff auf Funktionen # wie zum einlegen einer Pause im Code from time import sleep # ADC12 am GPIO2, als Eingang adc_pin = Pin(2, mode=Pin.IN) # Initialisieren eines ADC Objektes # (analog digital converter) adc = ADC(adc_pin) # Auflösung auf 0..1023 (10bit) adc.atten(ADC.ATTN_11DB) adc.width(ADC.WIDTH_10BIT) # Initialisiere den Piezo Buzzer auf Pin 25 # mit einer Frequenz von 440 Hz und einem Duty Cycle von 50% (512 von 1024) beeper = PWM(Pin(25), freq=440, duty=512) # Funktion zum Mappen der analogen Werte des Drehpotentiometers (0..1023) # auf eine Frequenz von 200 Hz bis 1500 Hz def map_value(x, in_min=0, in_max=1023, out_min=200, out_max=1500): return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min try: # Starten der Endlosschleife while True: analogValue = adc.read() frequenz = map_value(analogValue) beeper.freq(frequenz) print("analogValue:", analogValue) print("frequenz:", frequenz) sleep(0.25) except KeyboardInterrupt: # Deinitialisiere den PWM-Kanal, um den Ton zu stoppen beeper.deinit() Hier nun das komplette Programm zum steuern der Frequenz mit einem Drehpotentiometer. Natürlich kannst du auch einen Fotowiderstand verwenden welcher ähnlich funktioniert.

Ein Lied auf dem Piezo Buzzer abspielen

Ein Lied ist quasi lediglich eine Aneinanderreihung von Tönen, welche in einer bestimmten Frequenz und Dauer abgespielt werden. Natürlich kannst du über den Piezo Buzzer über diese technische Lösung keine umfangreichen MP3-Dateien abspielen, jedoch kleine Lieder im Klassischen 8Bit Style sind easy möglich. Programm - abspielen des Songs Für Elise von Beethoven auf dem ESP32 in MicroPythonHerunterladen Bei nachfolgenden Liedern habe ich mich aus dem GitHub Repository robsoncouto/arduino-songs bedient welche eigentlich für den Arduino gedacht sind, jedoch ist der Code so einfach, das man diesen mit wenig aufwand zu MicroPython konvertieren kann. from machine import Pin, PWM from time import sleep import urandom # Definition der Notenfrequenzen NOTE_B0 = 31 NOTE_C1 = 33 NOTE_CS1 = 35 NOTE_D1 = 37 NOTE_DS1 = 39 NOTE_E1 = 41 NOTE_F1 = 44 NOTE_FS1 = 46 NOTE_G1 = 49 NOTE_GS1 = 52 NOTE_A1 = 55 NOTE_AS1 = 58 NOTE_B1 = 62 NOTE_C2 = 65 NOTE_CS2 = 69 NOTE_D2 = 73 NOTE_DS2 = 78 NOTE_E2 = 82 NOTE_F2 = 87 NOTE_FS2 = 93 NOTE_G2 = 98 NOTE_GS2 = 104 NOTE_A2 = 110 NOTE_AS2 = 117 NOTE_B2 = 123 NOTE_C3 = 131 NOTE_CS3 = 139 NOTE_D3 = 147 NOTE_DS3 = 156 NOTE_E3 = 165 NOTE_F3 = 175 NOTE_FS3 = 185 NOTE_G3 = 196 NOTE_GS3 = 208 NOTE_A3 = 220 NOTE_AS3 = 233 NOTE_B3 = 247 NOTE_C4 = 262 NOTE_CS4 = 277 NOTE_D4 = 294 NOTE_DS4 = 311 NOTE_E4 = 330 NOTE_F4 = 349 NOTE_FS4 = 370 NOTE_G4 = 392 NOTE_GS4 = 415 NOTE_A4 = 440 NOTE_AS4 = 466 NOTE_B4 = 494 NOTE_C5 = 523 NOTE_CS5 = 554 NOTE_D5 = 587 NOTE_DS5 = 622 NOTE_E5 = 659 NOTE_F5 = 698 NOTE_FS5 = 740 NOTE_G5 = 784 NOTE_GS5 = 831 NOTE_A5 = 880 NOTE_AS5 = 932 NOTE_B5 = 988 NOTE_C6 = 1047 NOTE_CS6 = 1109 NOTE_D6 = 1175 NOTE_DS6 = 1245 NOTE_E6 = 1319 NOTE_F6 = 1397 NOTE_FS6 = 1480 NOTE_G6 = 1568 NOTE_GS6 = 1661 NOTE_A6 = 1760 NOTE_AS6 = 1865 NOTE_B6 = 1976 NOTE_C7 = 2093 NOTE_CS7 = 2217 NOTE_D7 = 2349 NOTE_DS7 = 2489 NOTE_E7 = 2637 NOTE_F7 = 2794 NOTE_FS7 = 2960 NOTE_G7 = 3136 NOTE_GS7 = 3322 NOTE_A7 = 3520 NOTE_AS7 = 3729 NOTE_B7 = 3951 NOTE_C8 = 4186 NOTE_CS8 = 4435 NOTE_D8 = 4699 NOTE_DS8 = 4978 REST = 0 # Ändere dies, um das Lied langsamer oder schneller zu machen tempo = 100 # Ändere dies auf den Pin, den du verwenden möchtest buzzer_pin = 25 buzzer = PWM(Pin(buzzer_pin)) # Noten der Melodie gefolgt von der Dauer melody = # Anzahl der Noten berechnen notes = len(melody) // 2 # Dauer einer ganzen Note in ms berechnen wholenote = (60000 * 4) / tempo led1 = Pin(17, Pin.OUT) led2 = Pin(16, Pin.OUT) led3 = Pin(27, Pin.OUT) led4 = Pin(14, Pin.OUT) leds = lastRandomNumber = -1 # Funktion zum Abspielen eines Tons def play_tone(pwm, freq, duration): pwm.freq(freq) pwm.duty(512) sleep(duration / 1000) pwm.duty(0) sleep(duration / 1000 * 0.1) # Setup und Melodie abspielen for i in range(0, len(melody), 2): note = melody duration = melody randomNumber = -1 while (lastRandomNumber == randomNumber): randomNumber = urandom.randint(0, 3) lastRandomNumber = randomNumber led = leds led.on() if duration > 0: note_duration = wholenote / duration else: note_duration = (wholenote / abs(duration)) * 1.5 if note == REST: sleep(note_duration / 1000) else: play_tone(buzzer, note, note_duration * 0.9) led.off() buzzer.deinit()

Ausblick

Im nächsten Beitrag werde ich dir zeigen, wie du mit einer Infrarot Fernbedienung die LEDs und den Piezo Buzzer bedienen kannst.

ESP32 D1 R32, Rich Shield + IR-Fernbedienung Read the full article

[draegerit]

View this post on Instagram

A post shared by Stefan Draeger (@draeger_it)

photo interrupter module and piezo buzzer at Arduino UNO R3 #photointerrupter #piezobuzzer #arduino #arduinouno #maker #diy #tech #techy #technology #electronic #components #microcontroller #draegerit (hier: Stefan Draeger Software) https://www.instagram.com/p/CTctzQVDd3p/?utm_medium=tumblr

[draegerit]

RGBDuino UNO mit NeoPixel, Piezo Buzzer und SMD LEDs an den digitalen Pins. #arduino #microcontroller #rgbduino #neopixel #PiezoBuzzer #maker #diy #tech #techy #technology #electronic #components #DraegerIT (hier: Stefan Draeger Software) https://www.instagram.com/p/CEw5Y58qfXt/?igshid=bbh4zs5yofef

[draegerit]

Weihnachtsevent 2019 im JFZ Schöningen - "Löten eines Weihnachtsbaums mit Sound"

Am 24.11 sowie 30.11.2019 hat im Jugendfreizeitzentrum Schöningen das Event "Löten eines Weihnachtsbaums mit Sound" stattgefunden.

PCB Weihnachtsbaum Den Aufbau des Weihnachtsbaums habe ich bereits im Beitrag Arduino Projekt: LED Weihnachtsbaum vorgestellt. Dieses Event war für interessierte von 10 bis 99 Jahre geöffnet. Besonders gefreut hat es mich das alle Plätze besetzt waren und es ohne größere Komplikationen stattgefunden hat. Durch die wenigen Komponenten war der Aufbau schnell erledigt und man konnte sich an die Programmierung wagen. Zunächst wurden die LEDs mittels ArduBlock angesteuert und zum leuchten / blinken gebracht.

Blinkende LED am PIN13 Im späteren Verlauf haben wir dann "richtigen" Quellcode mit der Programmiersprache C++ geschrieben und ein paar Töne auf den Piezo Buzzer ausgegeben. Die Teilnehmer hatten dabei viel Spaß und es wurden kleinere Programme geschrieben um die LEDs im wechsel mit den Tönen blinken zu lassen. Am Ende wurde das Sketch zum abspielen der Melodie "Jingle Bells" inkl. zufälligem wechsel von LEDs wurde auf die Microcontroller geschrieben und erläutert.     Read the full article

[draegerit]

Raspberry PI Tutorial #3: Piezo Buzzer

In diesem Tutorial möchte ich erläutern wie man einen Piezo Buzzer am Raspberry PI betreibt und einfache Töne mit diesem wiedergeben kann. Der Raspberry PI verfügt seit dem ersten Modell bereits über eine 3,5mm Klinkenbuchse über welchem man Musik abspielen kann, dieses Tutorial beschäftigt sich jedoch nur damit wie man einen Piezo Buzzer über GPIO Pins anschließt und mit Python programmiert.

Raspberry PI Modell B+ 3,5mm Klinkenbuchse

Bezug

Für dieses Tutorial verwende ich einen Raspberry PI Modell B+ dieser verfügt über ausreichend GPIO Pins und die Leistung von 700MHz ist mehr als ausreichend (dieses Tutorial kann mit einem einfachen Arduino nachgebaut werden welcher mit 16MHz Taktgeschwindigkeit läuft). Für dieses Tutorial benötigst du folgende Bauteile: 1x Raspberry PI, 1x Breadboard mit min. 400 Pins, 3x Breadboardkabel, 20cm, männlich - weiblich 1x aktiver Piezo Buzzer Es ist wichtig das es ein aktiver Piezo Buzzer ist! Der passive wird nur ein leises klicken produzieren.

Aufbau & Schaltung

Der Aufbau ist relativ simple denn wir benötigen hierfür "nur" einen GPIO Pin für das Datensignal sowie zwei Pins für die Stromversorgung des Active Buzzer Shields.

Active Buzzer Shield Anschluss Active Buzzer Shield Raspberry PI SIG GPIO 4 VCC 3,3V GND GND  Schaltung Wenn man alles so wie in der oben gezeigten Tabelle verkabelt sollte der Aufbau wie folgt aussehen.

Aufbau der Schaltung: aktiver Piezo Buzzer am Raspberry PI Modell B+ Sicherlich könnte man sich das Breadboard sparen und gleich Breadboardkabel mit nur Buchsen (weiblich - weiblich) verwenden, jedoch habe ich festgestellt das die Kabel gerne einmal herausrutschen.

Programmieren

Der Sketch ist ähnlich wie im Tutorial zur LED Raspberry PI Tutorial #1: blinkende LED, denn eigentlich aktivieren und deaktivieren wir zunächst nur einen GPIO Pin. import RPi.GPIO as GPIO import time GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) buzzer=4 GPIO.setup(buzzer,GPIO.OUT) try: while True: GPIO.output(buzzer,GPIO.HIGH) time.sleep(0.5) GPIO.output(buzzer,GPIO.LOW) time.sleep(0.5) except KeyboardInterrupt: GPIO.cleanup() pass

Video

Fazit

Am Anfang hatte ich einen einfachen, kleinen, passiven Piezo Buzzer verwendet. Dieses hatte ich bereits für den Arduino erfolgreich im Einsatz und war mir sicher das dieser genauso einfach am Raspberry PI betrieben werden kann. Aber dem war nicht so, denn der hatte nur in dem angegebenen Takt geklickt und das ganz leise.

Piezo Buzzer Eine Google suche gab hier die Lösung aus einem Forum, dort wurde genau das Problem bereits ausführlich behandelt und somit konnte ich mich der Lösung bedienen. Da ich bereits einen aktiven Piezo Buzzer besitze musste ich diesen nicht erst erwerben und ggf. Wochenlang auf die Lieferung aus China warten und konnte gleich weiter machen :) Der Aufbau war trotzdem sehr einfach und als nächstes möchte ich dann zeigen wie man einfache kleine Lieder wiedergeben kann.   Read the full article

[draegerit]

Arduino Lektion 88: Rich Shield von Open-Smart

In diesem Tutorial möchte ich das Rich Shield von Open-Smart vorstellen.

Rich Shield von Open-Smart Das Rich Shield von Open-Smart verfügt über: zwei Taster, einen Drehpotentiometer, einen NTC-Widerstand (Heißleiter), einen Fotowiderstand, vier LEDs (rot, grün, blau, gelb), einen Piezo Buzzer, einen DHT11 Sensor (Temperatur & Luftfeuchtigkeit), eine 4fach 7 Segmentanzeige (TM1637), eine Infrarot Diode, einen Spannungs Messer Zusätzlich verfügt das Shield über Pins an welche separat VCC, GND, SDA, SCL sowie TX und RX abgenommen werden kann. Eine Klemmleiste für den Anschluß von Vin rundet dieses Shield sehr gut ab. Das Shield verfügt wie oben erwähnt über eine Infrarot Diode, um diese zu nutzen kann man entweder extra eine Fernbedienung erwerben.

IR Fernbedienung für den Arduino und Raspberry Pi Oder aber man nutzt eine vorhandene von einem Fernseher, DVD-Player oder Reciver. Auch einige ältere Handys verfügen über eine IR Schnittstelle, hier könnte man mit einer entsprechenden App die Signale senden.

Bezug

Dieses Multifunktionale Rich Shield habe ich über ebay.de für knapp 7€ erstanden. Mittlerweile gibt es sogar Verpackungen welche eine IR Fernbedienung enthalten. Die Lieferung erfolgt in einer einfachen Plastikverpackung , mit Schaumstoff gepolstert. Ein PDF Dokument mit der Technischen beschreibung der Sensoren & Aktoren, findest du auf der Seite von https://www.arduinoall.com.

Sensoren & Aktoren auf dem Shield

LEDs Die vier, verschiedenfarbigen LEDs können jeweils über digitale Pins angesprochen werden. //definieren der LEDs #define LED_1 4 //LED1 rot #define LED_2 5 //LED2 grün #define LED_3 6 //LED3 blau #define LED_4 7 //LED4 gelb Sketch Im nachfolgenden möchte ich ein einfaches Lauflicht mit den LEDs durchführen. //definieren der LEDs #define LED_1 4 //LED1 rot #define LED_2 5 //LED2 grün #define LED_3 6 //LED3 blau #define LED_4 7 //LED4 gelb //Array mit den Pins für die LEDs int leds = {LED_1, LED_2, LED_3, LED_4}; //definieren der Werte für die Pausen //zwischen den einzelnen LEDs const int LONG_PAUSE = 250; const int SHORT_PAUSE = 75; void setup() { //setzen der LED als Ausgang pinMode(LED_1, OUTPUT); pinMode(LED_2, OUTPUT); pinMode(LED_3, OUTPUT); pinMode(LED_4, OUTPUT); } void loop() { //Das Array mit den Pins für die LEDs //von Anfang (INDEX=0) bis zum Index 3 durchlaufen for(int i=0;i=0;i--){ //aktivieren der LED digitalWrite(leds, HIGH); delay(LONG_PAUSE); //lange Pause //deaktivieren der LED digitalWrite(leds, LOW); delay(SHORT_PAUSE); //kleine Pause } } Video   Piezo Buzzer Mit dem Piezo Buzzer kann man verschiedene Töne und sogar einfach Lieder abspielen. Sketch Im nachfolgenden möchte ich ein kleines Sketch zeigen welches ich bereits für das Wemos D1 mini Shield: Buzzer Shield entwickelt habe. Es spielt auf dem Piezo Buzzer das Kinderlied "Alle meine Entchen." ab. int buzzer=3; #define a 1136 //Note a #define c 1915 //Note c #define d 1700 //Note d #define e 1519 //Note e #define f 1432 //Note f #define g 1275 //Note g //Die Noten int notes = {c, d, e, f, g, g,-1, a, a, a, a, g,-1, a, a, a, a, g,-1, f, f, f, f, e, e,-1, d, d, d, d, c}; //Die länge der Note int takt = {2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 2}; int tempo = 225; //Das Tempo des Liedes void setup() { Serial.begin(9600); //Begin der seriellen Kommunikation mit 9600 Baud pinMode(buzzer, OUTPUT); //Setzen des Buzzers als Ausgangssignal } void loop() { int numberOfNotes = sizeof(notes)/sizeof(int); int numberOfTakt = sizeof(takt)/sizeof(int); if(numberOfNotes != numberOfTakt){ Serial.println("Die Anzahl der Noten & Takte stimmen nicht überein!"); return; } //Für jede Note im Array for(int i=0; i 9999){ number = 0; } } Video   NTC-Widerstand Der NTC-Widerstand ist am analogen Pin A1 angeschlossen.

NTC-Widerstand auf dem Rich Shield von Open-Smart Einen NTC-Widerstand (auch als Heißleiter bezeichnet) habe ich bereits im Tutorial Arduino Lektion 84: NTC-Widerstand (Heißleiter) beschrieben. Auch das RTC Shield von Open-Smart welches ich unter Arduino Lektion 85: Multifunktionales Shield von Open-Smart beschrieben habe verfügt  unter anderem über einen NTC-Widerstand.  Sketch #include "TM1636.h" #include #include "functions.h" //Pins für das RTC Shield //#define CLK 7 //#define DATA 8 //Pins für das Rich Shield #define CLK 10 #define DATA 11 TM1636 tm1636(CLK, DATA); //An welchem analogen Pin der NTC-Widerstand angeschlossen ist #define PIN A1 const int ntcWiderstand = 10000; // NTC-Widerstand mit 10 kOhm const int MAX_ANALOG_VALUE = 1023; void setup(){ Serial.begin(9600); //Initialisieren der Anzeige. tm1636.init(); } void loop(){ double analogValue = analogRead(PIN); // Konvertieren des analogen Wertes in ein Widerstandswert double resistorValue = (MAX_ANALOG_VALUE / analogValue)- 1; resistorValue = ntcWiderstand / resistorValue; double kelvin = convert2TempKelvin(analogValue); double celsius = convertKelvin2TempCelsius(kelvin); tm1636.display(getNumber(celsius)); delay(1000); //eine kleine Pause 1sek. } double convert2TempKelvin(float value){ double temp = log(((10240000/value) - ntcWiderstand)); temp = 1 / (0.001129148 + (0.000234125 * temp) + (0.0000000876741 * temp * temp * temp)); return temp; } double convertKelvin2TempCelsius(double kelvin){ return kelvin - 273.15; } Download   Fotowiderstand Der Fotowiderstand ist am analogen Pin A2 angeschlossen. In einem früheren Tutorial habe ich bereits eine kleine Schaltung mit einem Fotowiderstand erzeugt und auch das RTC Shield von Open-Smart besitzt ein solches Bauteil. Download Video   DHT11 Sensor Der DHT11 Sensor kann die Temperatur und die relative Luftfeuchtigkeit messen. Diesen Sensor (und den großen Bruder DHT22) habe ich bereits im Tutorial Arduino Lektion 6: Sensor DHT11, Temperatur und relative Luftfeuchtigkeit messen erläutert. In diesem Abschnitt möchte ich nun darauf eingehen wie dieser Sensor am Rich Shield betrieben werden kann. Der DHT11 Sensor ist über den digitalen Pin D12 angeschlossen. Sketch - auslesen & Ausgabe auf dem seriellen Monitor Im nachfolgenden Sketch möchte ich zeigen wie man mit der Adafruit DHT11 Bibliothek den DHT11 Sensor auslesen und die Werte auf dem seriellen Monitor ausgeben kann.  Für diesen Sketch benötigst du neben der Bibliothek "DHT sensor library by Adafruit Version 1.3.3" auch zusätzlich die Adafruit Sensor Bibliothek welche du auf dem GitHub Repository von Adafruit herunterladen kannst. #include "DHT.h" //der DHT11 Sensor ist am digitalen Pin D12 angeschlossen #define DHTPIN 12 #define DHTTYPE DHT11 DHT dht(DHTPIN, DHTTYPE); void setup() { Serial.begin(9600); Serial.println("DHT11 Sensortest"); Serial.println("****************"); Serial.println(""); dht.begin(); } void loop() { //Der DHT11 Sensor liefert alle 1,5 Sekunden einen neuen Wert. delay(1500); //kleine Pause von 1,5 sek. //auslesen der relativen Luftfeuchtigkeit float luftfeuchtigkeit = dht.readHumidity(); //auslesen der Temepratur in Celsius float temperaturCelsius = dht.readTemperature(); //Wenn man der Funktion ein true übergibt, //erhält man den Wert in Fahrenheit. //Prüfen ob gültige Zahlenwerte gelesen wurden, wenn //dieses nicht so ist dann soll eine Fehlermeldung ausgegeben //werden und die loop an der Stelle verlassen werden. if (isnan(luftfeuchtigkeit) || isnan(temperaturCelsius)) { Serial.println("Fehler beim lesen des DHT11 Sensors"); return; } //ausgeben des Wertes für die relative Luftfeuchtigkeit Serial.print("relative Luftfeuchtigkeit: "); Serial.print(luftfeuchtigkeit); Serial.println("%"); //ausgeben des Wertes für die Temperatur in Celsius Serial.print("Temperatur: "); Serial.print(temperaturCelsius); Serial.println("°C"); } Video Sketch - ausgeben der Temperatur und der relativen Luftfeuchtigkeit auf der 4fach 7 Segmentanzeige Da das Rich Shield neben dem DHT11 Sensor, auch über eine 4fach 7 Segmentanzeige und zwei Taster verfügt so wollen wie diese nutzen um die Daten nicht auf den seriellen Monitor uns anzeigen zu lassen sonder eben über diese 4fach 7 Segmentanzeige. Dazu nutzen wir die Taster um zwischen den Werten für die relative Luftfeuchtigkeit (H), der Temperatur in °C (C) und der Temperatur in °F (F) zu wechseln. Ablauf: Wenn der Benutzer auf den linken Taster klickt, so soll ein Index um einen Zähler hinauf (+) gezählt werden. Wenn der Benutzer auf den rechten Taster klickt, so soll ein Index um einen Zähler hinab (-) gezählt werden. Wenn der Index gleich 1 ist, dann soll die relative Luftfeuchtigkeit angezeigt werden. Format der Ausgabe ist 3 Stellig, Ganzzahlig. Zusätzlich wird die rote LED aktiviert. Wenn der Index gleich 2 ist, dann soll die Temperatur in Celsius angezeigt werden. Format der Ausgabe 3 Stellig, Ganzzahlig. Zusätzlich wird die grüne LED aktiviert. Wenn der Index gleich 3 ist, dann soll die Temperatur in Fahrenheit angezeigt werden. Format der Ausgabe 3 Stellig, Ganzzahlig. Zusätzlich wird die blaue LED aktiviert. Download   Video In dem Video kommt leider die Helligkeit der grünen LED nicht so ganz zur Geltung.   Infrarot Diode (IR-Empfänger) Die Infrarot Diode auf dem Rich Shield ist am digitalen Pin D3 angeschlossen.

Infrarot Diode am Rich Shield von Open-Smart Eine Schaltung mit einer Infrarot Diode habe ich bereits in dem Tutorial Arduino Lektion 20: IR Fernbedienung auslesen ausführlich erläutert. Sketch Zunächst einmal muss man die verwendete IR Fernbedienung auslesen, hier hat jede Taste ihren eigenen Code. Der Einfachheit lasse ich mir diese Werte auf dem seriellen Monitor der Arduino IDE ausgeben. #include #define IR_DIODE 2 //IR Diode am digitalen Pin D2 //Objekt initialisieren für die IR Übertragung IRrecv irrecv(IR_DIODE); decode_results results; void setup() { pinMode(IR_DIODE, INPUT); //Den IR Pin als Eingang deklarieren. irrecv.enableIRIn(); //Den IR Pin aktivieren Serial.begin(9600); //Serielle kommunikation mit 9600 Baud beginnen. } void loop(){ if (irrecv.decode(&results)) { //Wenn etwas gelesen wurde dann... //Ausgabe des Wertes auf die Serielle Schnittstelle. Serial.println(results.value); irrecv.resume(); // auf den nächsten Wert warten } } Für den nachfolgenden Sketch verwende ich nun eine einfache Fernbedienung welche über ebay.de für knapp 4€ inkl. Versandkosten erstanden werden kann.

einfache IR Fernbedienung für den Arduino Folgende Funktionen möchte ich mit der Fernbedienung ausführen: Taste 1 - LED1 aktivieren / deaktivieren Taste 2 - LED2 aktivieren / deaktivieren Taste 3 - LED3 aktivieren / deaktivieren Taste 4 - LED4 aktivieren / deaktivieren #include #define IR_DIODE 2 //IR Diode am digitalen Pin D2 //definieren der LEDs #define LED_1 4 //LED1 rot #define LED_2 5 //LED2 grün #define LED_3 6 //LED3 blau #define LED_4 7 //LED4 gelb int led1Status = 0; int led2Status = 0; int led3Status = 0; int led4Status = 0; const int TASTE_1 = 12495; const int TASTE_2 = 6375; const int TASTE_3 = 31365; const int TASTE_4 = 4335; const int MAGIC_NUMBER = -1; //Objekt initialisieren für die IR Übertragung IRrecv irrecv(IR_DIODE); decode_results results; void setup() { pinMode(LED_1, OUTPUT); pinMode(LED_2, OUTPUT); pinMode(LED_3, OUTPUT); pinMode(LED_4, OUTPUT); pinMode(IR_DIODE, INPUT); //Den IR Pin als Eingang deklarieren. irrecv.enableIRIn(); //Den IR Pin aktivieren Serial.begin(9600); //Serielle kommunikation mit 9600 Baud beginnen. } void loop(){ if (irrecv.decode(&results)) { //Wenn etwas gelesen wurde dann... //Ausgabe des Wertes auf die Serielle Schnittstelle. int value = results.value; switch(value){ case TASTE_1: toggleLED(LED_1, led1Status); break; case TASTE_2: toggleLED(LED_2, led2Status); break; case TASTE_3: toggleLED(LED_3, led3Status); break; case TASTE_4: toggleLED(LED_4, led4Status); break; case MAGIC_NUMBER: break; //Nichts machen wenn die Zahl ausgegeben wird. } irrecv.resume(); // auf den nächsten Wert warten } } void toggleLED(int pin, int ledStatus){ int newLedStatus = ledStatus == LOW ? HIGH : LOW; switch(pin){ case LED_1: led1Status= newLedStatus; break; case LED_2: led2Status= newLedStatus; break; case LED_3: led3Status= newLedStatus; break; case LED_4: led4Status= newLedStatus; break; } Serial.print("LED an Pin "); Serial.print(pin); Serial.print(newLedStatus==HIGH?" aktivieren":" deaktivieren"); Serial.println("!"); digitalWrite(pin, newLedStatus); } Video   Spannungsmesser Der Spannungsmesser am Rich Shield ist über eine kleine Schraubklemme zu erreichen.

Rich Shield: Spannungssensor (Voltagesensor) Es gibt leider keine Angabe welcher Spannungsbereich gemessen werden kann. Jedoch gibt es von Open-Smart den Spannungssensor auch einzeln zu erwerben und dieser hat einen Messbereich Read the full article

[draegerit]

Arduino Lektion 85: Multifunktionales Shield von Open-Smart

In diesem Tutorial möchte ich ein weiteres Multifunktionales Shield von der Firma "Open Smart" vorstellen. Die Zielgruppe für dieses Shield sind ganz klar die Anfänger im Bereich Microcontrollerentwicklung. Da das Shield direkt auf den Arduino UNO / Leonardo gesteckt werden kann entfällt eine aufwendige und ggf. fehlerbehaftete Verkabelung und man kann fast direkt mit der Programmierung beginnen.

Bezug

Das mir vorliegende Shield habe ich über Aliexpress für knapp 6$ inkl. Versandkosten erworben. Ich denke jedoch das dieses auch bald bei ebay.de erhältlich sein wird. (Es dauert nach meiner Erkenntnis ca. 4-5 Monate und dann sind diese Module und Shields auch auf ebay.de erhältlich.)

Ausstattung des Multifunktionalen Shields

Das Multifunktionale Shield verfügt über: 4fach 7 Segment Anzeige (TM1636), RealTimeClock DS1307, Piezzo Buzzer, Thermistor (NTC-Widerstand), Fotowiderstand, LEDs, Buttons Die meisten dieser Sensoren / Aktoren habe ich bereits gesondert in Tutorials behandelt (Links sind hinter den Texten hinterlegt.) daher möchte ich auf kleine Beispiele mit diesen und dem Shield eingehen. Das Shield wurde leider ohne Anleitung geliefert d.h. man muss zunächst einmal prüfen wo welche Sensoren / Aktoren angeschlossen sind. Hier reicht jedoch ein prüfender Blick auf der Platine denn die Leiterbahnen sind sehr gut zu erkennen und somit habe ich folgende Anschlüsse ermitteln können: LEDs D1 - digitaler Pin D2 D2 - digitaler Pin D3 D3 - digitaler Pin D4 NTC-Widerstand analoger Pin A0 Fotowiderstand analoger Pin A1 Buttos (Taster) K1 - digitaler Pin D9 K2 - digitaler Pin D10 K3 - digitaler Pin D11 Piezo Buzzer digitaler Pin D6 RTC DS1307 analoger Pin A4 - SDA analoger Pin A5 - SCL 4fach 7 Segmentanzeige digitaler Pin D8 - CLK

Programmieren

Wie bereits erwähnt habe ich die meisten der Sensoren / Aktoren bereits behandelt, daher möchte ich im folgenden einige kleine Beispiele aufzeigen wie diese verwendet werden können.  Piezo Buzzer Der Piezo Buzzer ist am digitalen Pin D6 angeschlossen und kann verschiedene Töne von sich geben. #define BUZZER 6 int minValue = 100; int maxValue = 1500; void setup() { pinMode(BUZZER, OUTPUT); } void loop() { //von der Frequenz minValue bis maxValue for(int i = minValue;iminValue;i--){ playTone(i); } } void playTone(int freq){ //gibt einen Ton auf dem Buzzer wieder mit der Frequenz freq und //einer dauer von 25ms. tone(BUZZER, freq,25); //kleine Pause von 2ms. delay(2); } LEDs Das Shield verfügt über zwei rote, eine grüne und eine blaue LED. Im folgenden Sketch erzeuge ich mit diesen 4 LEDs ein kleines Lauflicht. #define LED_RED1 5 #define LED_RED2 4 #define LED_GRUEN 3 #define LED_BLAU 2 const int PAUSE = 125; void setup() { pinMode(LED_RED1,OUTPUT); pinMode(LED_RED2,OUTPUT); pinMode(LED_GRUEN,OUTPUT); pinMode(LED_BLAU,OUTPUT); } void loop() { lightUpLed(LED_RED1); lightUpLed(LED_RED2); lightUpLed(LED_GRUEN); lightUpLed(LED_BLAU); } void lightUpLed(int pin){ delay(PAUSE); digitalWrite(pin, HIGH); delay(PAUSE); digitalWrite(pin, LOW); } Video Hier nun ein kleines Video, wie das oben gezeigte Sketch funktioniert.   Buttons (Taster) Auf dem Multifunktions Shield sind 3 Taster verbaut, diese Taster öffnen den Kontakt beim drücken d.h. das Signal ist zunächst auf LOW und wenn der Taster gedrückt wird ist dieser HIGH. #define BTN_1 9 #define BTN_2 10 #define BTN_3 11 void setup() { Serial.begin(9600); pinMode(BTN_1, INPUT); pinMode(BTN_2, INPUT); pinMode(BTN_3, INPUT); digitalWrite(BTN_1, HIGH); digitalWrite(BTN_2, HIGH); digitalWrite(BTN_3, HIGH); } void loop() { if(digitalRead(BTN_1) == LOW){ printMsg(1); } if(digitalRead(BTN_2) == LOW){ printMsg(2); } if(digitalRead(BTN_3) == LOW){ printMsg(3); } } void printMsg(int number){ Serial.print("Taster Nummer "); Serial.print(number); Serial.println(" wurde gedrückt."); } Was nun beim dem oben gezeigten Sketch auffällt ist das die Taster "prellen", d.h. beim drücken der Taster wird mehrmals ein Signal empfangen obwohl nur 1x kurz der Taster betätigt wurde.  Wie man dieses Prellen abstellen kann habe ich im Tutorial XYZ beschrieben. Video   Fotowiderstand Ein Fotowiderstand ist ein Widerstand welcher Licht abhängig seine größe bestimmt. D.h. je höher die Lichtintensität welche auf den Fotowiderstand wirkt desto kleiner ist sein innerer Widerstand. Den Fotowiderstand habe ich bereits im Tutorial Arduino Lektion 4: LED mit Fotowiderstand ausführlich behandelt. Da das Shield über 4 LEDs verfügt wollen wir diese nutzen um die aktuelle Lichtintensität anzuzeigen. Der minimale Wert ist 0 und der maximale Wert 1023. Um diese Werte auf die 4 LEDs zu mappen gibt es die Funktion map.  Die Funktion map hat 5 Parameter: map(value, fromLow, fromHigh, toLow, toHigh) Um dieses nun für unsere LEDs zu mappen sieht dieses dann wiefolgt aus: int photoResistorValue = analogRead(FOTOWIDERSTAND); int ledNum = map(photoResistorValue,0,1023,0,3 ); Hier nun der gesamte Sketch: #define LED_RED1 5 #define LED_RED2 4 #define LED_GRUEN 3 #define LED_BLAU 2 #define FOTOWIDERSTAND A1 int leds = {LED_RED1,LED_RED2,LED_GRUEN,LED_BLAU}; void setup() { pinMode(LED_RED1,OUTPUT); pinMode(LED_RED2,OUTPUT); pinMode(LED_GRUEN,OUTPUT); pinMode(LED_BLAU,OUTPUT); } void loop() { int photoResistorValue = analogRead(FOTOWIDERSTAND); int ledNum = map(photoResistorValue,0,1023,0,3 ); lightUpLed(leds); delay(250); } void lightUpLed(int pin){ resetLeds(); digitalWrite(pin, HIGH); } void resetLeds(){ for(int i=0;i 0){ disp = SPACE; } else { //Wenn die Temperatur kleiner als 0°C ist so soll ein Minuszeichen angezeigt werden. disp = NEGATIVE_SIGN; } //Jedes Zeichen in dem String mit dem Temperaturwert durchlaufen. for(int i = 0;i //Lesen des Zeichens an der Stelle i im String. //Als Rückgabe erhält man hier ein Zahlenwert aus der ASCII Tabelle. int pos = temp.charAt(i); //Ungültige Zeichen rausfiltern. //Im String gibt es unsichtbare, Steuerzeichen welche wir auf dem Display //nicht anzeigen möchten / können. if(pos != 3 && pos != 7 && pos != 13 && pos != 16 && pos != 46){ //Die Zahlen beginnen beim ASCII Wert 48 (48 = 0), somit ziehen wir von dem gelesenen Wert 48 ab //und erhalten unseren Index aus dem Array mit den Zahlenwerten für das Display. pos = pos - 48; disp = values; } } //Anzeigen der Temperatur auf dem Display. tm1636.display(disp); //eine kleine Pause 1500ms. delay(1500); } double readNTCValue(){ float analogValue = analogRead(PIN); float resistorValue = (MAX_ANALOG_VALUE / analogValue)- 1; resistorValue = ntcWiderstand / resistorValue; double kelvin = convert2TempKelvin(analogValue); double celsius = convertKelvin2TempCelsius(kelvin); return celsius; } double convert2TempKelvin(float value){ double temp = log(((10240000/value) - ntcWiderstand)); temp = 1 / (0.001129148 + (0.000234125 * temp) + (0.0000000876741 * temp * temp * temp)); return temp; } double convertKelvin2TempCelsius(double kelvin){ return kelvin - 273.15; } int8_t* displayValues(int temp){ } Video RealTimeClock DS1307 Auf dem Multifunktionalen Shield ist zusätzlich eine RealTimeClock vom Typ DS1307 verbaut. Die Schaltungen und Beispiele im Vorfeld zu diesem Kapitel habe ich mit dem Microcontroller Arduino Leonardo gemacht, jedoch benötigte ich für das betreiben der RTC DS1307 einen Arduino UNO. Das liegt vielmehr daran das auf dem Multifunktionalem Shield von Open-Smart die Pins für SDA & SCL auf den analogen Pin A4 bzw. analogen Pin A5 gelegt sind und dieses "nur" am Arduino UNO funktioniert. Bezug der benötigten Bibliotheken Zunächst einmal benötigen wir wieder eine Bibliothek welche uns die Arbeit mit der RTC Ds1307 erleichtert. In meinem Fall wähle ich die Bibliothek "DS1307RTC" von Paul Stoffregen welcher auf seinem GitHub Repository diese zum Download anbietet. Zusätzlich zur genannten Bibliothek benötigt man noch die Bibliothek "TimeLib" hier benutze ich wiederum die Bibliothek von Paul Stoffregen welche auch vom GitHub Repository heruntergeladen werden kann. Wenn beide Bibliotheken heruntergeladen und erfolgreich installiert wurden so kann mit der eigentlichen Programmierung begonnen werden. Der Bibliothek "DS1307RTC" liegen 2 sehr gute Beispiele bei welche ich im weiteren verwenden werde um die RTC am Arduino UNO zu betreiben.

Beispiele zur Bibliothek "DS1307RTC" von Paul Stoffregen Programmieren der RTC DS1307 setzen der aktuellen Uhrzeit Für das setzen der aktuellen Uhrzeit kann man das Beispiel "SetTime" aus der Bibliothek "DS1307RTC" verwenden. #include #include #include const char *monthName = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; tmElements_t tm; void setup() { bool parse=false; bool config=false; //Setzen des Datums & der Uhrzeit von dem Zeitstempel //wann der Sketch kompiliert wurde. if (getDate(__DATE__) && getTime(__TIME__)) { parse = true; //Schreiben der Daten auf die RTC. //Da die RTC über eine Pufferbatterie verfügt wird sich dieser Wert //über einen langen Zeitraum "gemerkt". if (RTC.write(tm)) { config = true; } } Serial.begin(9600); //Warten das der serielle Ausgang bereitsteht. //Dieses kann besonders beim Arduino Leonardo etwas dauern. while (!Serial) ; delay(200); //kleine Pause von 200ms. //Wenn das parsen des Zeitstempels & das Schreiben auf der RTC erfolgreich waren dann... if (parse && config) { Serial.print("DS1307 configured Time="); Serial.print(__TIME__); Serial.print(", Date="); Serial.println(__DATE__); } else if (parse) { //Wenn nur das parsen des Zeitstempels erfolgreich war dann... Serial.println("DS1307 Communication Error :-{"); Serial.println("Please check your circuitry"); } else { //andernfalls soll eine Fehlermeldung auf dem seriellen Ausgang ausgegeben werden. Serial.print("Could not parse info from the compiler, Time=\""); Serial.print(__TIME__); Serial.print("\", Date=\""); Serial.print(__DATE__); Serial.println("\""); } } void loop() { //bleibt leer } //Liefert true wenn das Parsen der Uhrzeit erfolgreich war. bool getTime(const char *str){ int Hour, Min, Sec; //befüllen der Variablen für Stunde, Minute und Sekunde aus dem übergebenen String. //Als Rückgabe erhält man eine ganze Zahl welche die Anzahl verarbeiteten Variablen repräsentiert. //In diesem Fall müssen 3 Variablen verarbeitet werden, wenn dieses nicht so ist wird die Methode //false zurück liefern. if (sscanf(str, "%d:%d:%d", &Hour, &Min, &Sec) != 3){ return false } tm.Hour = Hour; tm.Minute = Min; tm.Second = Sec; return true; } //Liefert true wenn das Parsen des Datums erfolgreich war. bool getDate(const char *str){ char Month; int Day, Year; uint8_t monthIndex; //befüllen der Variablen für Monat, Tag und Jahr aus dem übergebenen String. //Als Rückgabe erhält man eine ganze Zahl welche die Anzahl verarbeiteten Variablen repräsentiert. //In diesem Fall müssen 3 Variablen verarbeitet werden, wenn dieses nicht so ist wird die Methode //false zurück liefern. if (sscanf(str, "%s %d %d", Month, &Day, &Year) != 3){ return false; } for (monthIndex = 0; monthIndex if (strcmp(Month, monthName) == 0) break; } //Wenn der Index des Monats größer, gleich 12 ist dann soll false zurück geliefert werden. //Die Monate beginnen immer mit dem Index 0 (0=Januar, ..., 11=Dezember) if (monthIndex >= 12){ return false; } tm.Day = Day; tm.Month = monthIndex + 1; tm.Year = CalendarYrToTm(Year); return true; } auslesen der Uhrzeit Die RTC verfügt über eine Pufferbatterie, diese Batterie befindet sich unter der 4fach 7 Segmentanzeige.

RTC DS1307 Pufferbatterie auf dem Multifunktionalem Shield von Open-Smart Die Pufferbatterie sorgt dafür das die einmal gesetzte Zeit gespeichert wird und fortgezählt wird somit ist beim nächsten starten des Arduinos kein erneutes setzen der Uhrzeit notwendig. #include #include #include void setup() { //Beginn der seriellen Kommunikation mit 9600 baud. Serial.begin(9600); //Warten darauf das der Serielle Ausgang bereit ist. //Dieses kann beim Arduino Leonardo etwas länger dauern. while (!Serial) ; delay(200); //eine kleine Pause von 200ms. Serial.println("DS1307RTC Read Test"); Serial.println("-------------------"); } void loop() { tmElements_t tm; //Wenn Daten von der RTC erfolgreich gelesen wurden dann... if (RTC.read(tm)) { Serial.print("Ok, Time = "); print2digits(tm.Hour); //Stunde ausgeben Serial.write(':'); print2digits(tm.Minute); //Minute ausgeben Serial.write(':'); print2digits(tm.Second); //Sekunden ausgeben Serial.print(", Date (D/M/Y) = "); Serial.print(tm.Day); //Tag ausgeben Serial.write('/'); Serial.print(tm.Month); //Monat ausgeben Serial.write('/'); Serial.print(tmYearToCalendar(tm.Year)); //Jahr ausgeben Serial.println(); } else { //Wenn keine Daten gelesen wurden, so soll eine Meldung ausgegeben werden. if (RTC.chipPresent()) { //Wenn eine RTC erkannt wurde dann... Serial.println("The DS1307 is stopped. Please run the SetTime"); Serial.println("example to initialize the time and begin running."); Serial.println(); } else { //Wenn keine RTC erkannt wurde dann... Serial.println("DS1307 read error! Please check the circuitry."); Serial.println(); } delay(9000); //Pause von 9sek. } delay(1000); //Pause von 1sek. } //Wenn die Zahl kleiner als 10 ist so soll eine führende 0 hinzugefügt werden. void print2digits(int number) { if (number >= 0 && number Serial.write('0'); } Serial.print(number); }   Read the full article

[draegerit]

BBC micro:bit #2: Sprachausgabe

Der BBC micro:bit hebt sich vom Arduino und deren Clones in der Programmierung deutlich ab. Wir können zbsp. auch ganz einfach Sprachausgaben an diesem Microcontroller generieren. Dabei ist die Sprachqualität natürlich etwas eingeschränkt aber es funktioniert schon recht gut.

Was wird benötigt?

Wir benötigen dazu folgende Bauelemente: 1x BBC micro:bit 1x Erweiterungskarte (für den BBC micro:bit) 2x Breadboardkabel, 10cm, männlich - weiblich Nun gibt es zwei Arten wie wir die Sprachausgabe uns anhören können, einmal mit einem einfachen Piezo Buzzer oder mit einer aktiv Box. Aufbau mit dem Piezo Buzzer Möchte man die Schaltung mit einem Piezo Buzzer aufbauen so benötigt man neben die oben genannten Bauteile nur noch zusätzlich einen Piezo Buzzer (im nachfolgenden nur als Buzzer bezeichnet).

Piezo Buzzer Einen Buzzer kann man bei ebay.de schon für ca. 3€ erwerben. (Eine große Preisersparnis kann man mit 5er oder 10er Packungen erhalten.)

Schaltung - Erweiterungskarte für den BBC micro:bit mit Piezo Buzzer Der Nachteil bei einem Piezo Buzzer ist das dieser sehr leise ist jedoch ist dieser deutlich günstiger und kleiner. 

Aufbau - BBC micro:bit mit Piezo Buzzer Video In diesem kurzen Video möchte ich aufzeigen wie die Sprachausgabe auf einem Piezo Buzzer klingt.   Aufbau mit einer aktiv Box Wer etwas mehr Qualität haben möchte der nutzt eine aktiv Box. Diese gibt es schon für wenige Euros im Discounter. Ich nutze für dieses Tutorial die Computerboxen "Logitech  Z213 2.1". Um an dem 3,5 Klinkenstecker die Pins 1 und 2 anzuschließen benötigen wir zusätzlich noch 2 Krokodilklemmen, diese gibt es für ca. 6€ in einer 10er Packung auf ebay.de zu kaufen.

Krokodilklemmen Mit diesen "Klammern" können wir nun die beiden Pins 0 & 1 an den 3,5 Klinkenstecker anschließen. Dazu greifen wir zunächst die Pins von der Erweiterungskarte mit Breadboardkabeln ab und klemmen an diese ein Ende von unseren Krokodilklemmen. Das andere Ende der Krokodilklemmen, klemmen wir an den 3,5 Klinkenstecker hier müssen wir die Spitze und das Ende verbinden.

Anschluss - Krokodilklemmen am 3,5 Klinkenstecker Wenn wir alles angeschlossen haben dann sollte unserer Aufbau ungefähr so aussehen:

Anschluss - BBC micro:bit an aktiv Boxen Video Man hört in dem Video einen deutlichen Unterschied zum einfachen Piezo Buzzer.

Quellcode

Nachdem ich nun gezeigt habe welche 2 Möglichkeiten es gibt die Schaltung aufzubauen. Müssen wir natürlich zunächst einmal dem BBC micro:bit programmieren.  Neben der Bibliothek "microbit", welche die Basisfunktionen für den Microcontroller liefert benötigen wir zusätzlich für unsere Sprachausgabe die Bibliothek "speech". Nun können wir in unserer Endlosschleife mit der Funktion "speech.say" einen einfachen englischen Text ausgeben. Es werden bisher nur englische Wörter / Sätze unterstützt. Nach der Sprachausgabe habe ich eine kleine Pause von 2sek. eingefügt. # Bibliothek mit den Funktionen für den BBC micro:bit from microbit import * # Bibliothek mit den Funktionen für die Sprachausgabe import speech while True: # den Text ausgeben speech.say("This is a simple Test.") # eine kleine Pause von 2 sek. sleep(2000)

manipulieren der Sprachausgabe

Die Sprachausgabe erfolgt wie bereits erwähnt in englischer Sprache, was man jedoch manipulieren kann ist die Geschwindigkeit, die Höhe und die sowie wie diese klingt. Die Klangfarbe lässt sich mit zwei Parametern beeinflussen, jeweils ob man mehr dumpf spricht (wie eine Bauchrednerpuppe) oder sehr aufgeregt. speed Die Geschwindigkeit mit welcher der Text wiedergegeben wird. Der minimale Wert von "0" ist die schnellste Geschwindigkeit und der maximale Wert von "255" ist der schnellste. Bei einer Wahl von der Geschwindigkeit hört man nur ein kleines piepen somit bewegt sich meine Auswahl irgendwo in der Mitte. pitch Die Höhe der Stimme bestimmt man mit dem Parameter "pitch". Der minimale Wert von "0" ist sehr hoch und der maximale Wert von "255" sehr tief. throat Mit dem Parameter "throat" wird bestimmt wie relaxed oder angespannt die Stimme klingen soll. Der minimale Wert von "0" klingt sehr entspannt und der maximale Wert von "255" klingt sehr angespannt. mouth Der Parameter "mouth" manipuliert die Stimme in der Form das beim minimalen Wert von "0" diese sehr dumpf klingt und beim maximalen Wert von "255" sehr offen. Beispiel Hier nun ein kleines Beispiel mit dem allseits  bekannten Text "Hello World!". Wenn der Benutzer auf den Button "A" klickt dann wird die Funktion "saySomething" aufgerufen. In dieser Funktion wird nun unser Text als Sprache ausgegeben. # Bibliothek mit den den Funktionen für den micro:bit from microbit import * # Bibliothek für die Sprachausgabe import speech # Funktion um einen Text als Sprache auszugeben. def saySomething(): speech.say("Hello World!", speed=85, pitch=120, throat=125, mouth=150) # Endlosschleife while True: # Wenn der Button "A" gedrückt wird dann mache... if button_a.is_pressed(): # Funktion aufrufen saySomething() Für dieses Beispiel wurde am Ende der Endlosschleife kein "sleep" eingebaut, da diese Funktion eine kleine Pause bewirkt könnte der Microcontroller sonst den Status (Button gedrückt) des Buttons "A" verpassen bzw. erst etwas später anfangen den Text auszugeben.

Fazit

Mit der Bibliothek "speech" und einem Aktivlautsprecher kann man sich einfache Texte ausgeben und dem BBC micro:bit etwas "leben" einhauchen. Eine ausführliche Dokumentation zu dieser Bibliothek findest du unter https://microbit-micropython.readthedocs.io/en/latest/tutorials/speech.html. Auf der Webseite wird jedoch hervorgehoben das die Bibliothek "speech" sich z.Zt. (stand 03.032019) sich im AlphaCode Status befindet, d.h. es wird weiter an dieser Entwickelt aber der aktuelle Stand ist "gut genug" um veröffentlicht zu werden.  Read the full article

[draegerit]

View this post on Instagram

A post shared by Stefan Draeger (@draeger_it)

Weihnachtsbaum mit LEDs und Buzzer, am Arduino Nano Ein kleines Projekt aus dem Jahr 2018 welches ich dieses Jahr am JFZ Schöningen anbiete. #arduino #arduinoproject #arduinonano #maker #led #PiezoBuzzer #christmastree (hier: Stefan Draeger Software) https://www.instagram.com/p/B3je_hajfKU/?igshid=17bh4laif62f8

[draegerit]

View this post on Instagram

A post shared by Stefan Draeger (@draeger_it)

Rich Shield von Open Smart. Ein Kinderlied auf dem Piezo Buzzer. Wer erratet es? Ab in die Kommentare! #richshield #opensmart #PiezoBuzzer #buzzer #arduino #arduinoproject #arduinouno #techy #tech #maker #electronic #components #diy #DraegerIT (hier: Stefan Draeger Software) https://www.instagram.com/p/BxknjDGIhhj/?igshid=141rdygy2cr19

[draegerit]

Arduino Lektion 51: analoger Temperatursensor LM393

Der analoge Temperatursensor LM393, dient nicht nur zum Temperaturmessen, sondern kann auch durch den verbauten Drehpotentiometer auf einen Wert zwischen 20 °C und 80 °C eingestellt werden. Beim Erreichen der Temperatur wird ein HIGH Signal auf den digitalen Ausgang gelegt.

Temperatursensor LM393

Technische Daten des LM393

- Betriebsspannung - 3.3V bis 5V - Ausgangsstrom - 15mA - Abmaße - 35 mm x 15 mm - Temperaturmessbereich  - +20 °C bis +80 °C

Anschluss

Der Sensor verfügt über 4 Pins welche wie folgt mit dem Arduino UNO verbunden werden. LM393 Arduino UNO  A0 analoger Pin A0 + 5V G GND D0 digitaler Pin 7

Schaltung

Temperatursensor LM393 am MakerUno Einstellen des Schwellwertes Der Schwellwert des Temperatursensors wird über einen Drehpotentiometer eingestellt. Dreht man diesen im Uhrzeigersinn so wird der Schwellwert erhöht und dreht man diesen gegen den Uhrzeigersinn so wird dieser Wert verkleinert. Da dieser Sensor "nur" einen Momentanen Temperaturwert ausgeben kann, muss hier etwas experimentiert werden wenn man einen ganz bestimmten Schwellwert haben möchte. Hier schwächelt der Sensor leider etwas.

Drehpotentiomenter am LM393 Temperatursensor Wenn der Schwellwert erreicht ist, dann wird der digitale Ausgang des Sensors auf HIGH gesetzt sowie wird eine onboard LED eingeschaltet und es kann ein weiterer Aktor geschaltet werden.

Temperatursensor LM393 Schwellwert erreicht.

Quellcode

const int digitalPin = 7; //D0 vom LM393 const int analogPin = A0; //A0 vom LM393 const int ledPin = 13; // internet LED an Pin 13 //Der MakerUNO verfügt über einen verbauten Piezobuzzer //dieser wird über den Pin 8 angesprochen. const int buzzerPin = 8; void setup(){ Serial.begin(9600); //Beginn der seriellen Kommunikation mit 9600 baud pinMode(ledPin, OUTPUT); pinMode(buzzerPin, OUTPUT); pinMode(digitalPin, INPUT); } void loop(){ //lesen des analogen Wertes int analogValue = analogRead(analogPin); //lesen des zustandes, Schwellwert erreicht / nicht erreicht boolean state = digitalRead(digitalPin); //Ausgabe ob der Schwellwert erreicht wurde. Serial.print("digitaler Ausgang ist "); Serial.println(state==HIGH?"AN": "AUS"); //Ausgabe der Temperatur. Serial.print("Temperatur:"); Serial.println(getTempC(analogValue)); //Wenn der Schwellwert des Temperatursensors erreicht //wurde, dann soll die interne LED am PIN 13 aufleuchten. digitalWrite(ledPin,state); //Wenn der Schwellwert erreicht wurde so soll ein Ton erzeugt werden. //Hier könnte man auch ein Relais anschließen oder sonstige andere Aktoren //welche auf den Umstand hinweisen sollen. if(state==HIGH){ tone(buzzerPin, 1000, 500); } delay(1000); //kleine Pause von 1 Sekunde. } double getTempC(int analogValue){ int mappedAnalogValue = map(analogValue, 0, 1023, 1023, 0); double tempC = log(((10240000 / mappedAnalogValue) - 10000)); tempC = 1 / (0.001129148 + (0.000234125 * tempC) + (0.0000000876741 * tempC * tempC * tempC)); tempC = tempC - 273.15; return tempC; }

Video

Read the full article