Berührungsloser musikalischer Handwasch-Timer

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Während das Händewaschen seit jeher ein wichtiges Arsenal für die Prävention von Krankheiten und die allgemeine Gesundheit war, hat es als Präventivmaßnahme zur Eindämmung der Ausbreitung der COVID-19-Pandemie eine neue Bedeutung erlangt.

Die CDC-Richtlinie für gutes Händewaschen besagt, dass man sich idealerweise die Hände 20 Sekunden lang schrubben muss. https://www.cdc.gov/handwashing/when-how-handwashing.html

🤓📚** Extras ** 🤓📚 Hier ist etwas über die Wissenschaft hinter dem Händewaschen, wenn Sie interessiert sind! - https://www.cdc.gov/handwashing/show-me-the-science-handwashing.html

In dieser Redux eines Handwasch-Timers wird unser musikalischer Handwasch-Timer durch Winken mit der Hand vor einem Ultraschallsensor aktiviert und zeigt den Countdown auf einer 7-Segment-Anzeige an. Um es interessanter zu machen, spielt es auch eine rotierende Auswahl von 20-Sekunden-Jingles aus einer Liste vorprogrammierter Jingles ab. Sie können Ihre eigene Musik ganz einfach hinzufügen, indem Sie jede vorhandene Notennotation transkribieren!

Hier ist ein Blick auf das Touchless Musical Handwasch-Timer in Aktion, zeigt alle 4 Jingles, die ich in

• Alles Gute zum Geburtstag

• Do-Re-Mi (Sound of Music)

• Wir werden dich rocken (Queen)

• Jeopardy-Themenmusik

Junge, meine Hände waren super-duper sauber bis zum ende!

🤓📚** Extras ** 🤓📚Inzwischen wissen wir alle, dass das zweimalige Singen von „Happy Birthday to You“ etwa 20 Sekunden dauert und es zu einem De-facto-Standard für das Händewaschen geworden ist, sogar von Kanadas Premierminister Justin Trudeau gesungen! Dr. Theresa Tam, Kanadas Chief Public Health Officer, hat ihre eigenen Favoriten wie We Will We Will Wash You ! 😊Sehen Sie sich unten dieses faszinierende Interview von Arjun Ram an, einem Mitwirkenden von CBC Kids News.

Ich präsentiere beide Songs in unserem Touchless Musical Hand Wash Timer , plus ein paar mehr!

Schritt 1 - Schema

Dieses Projekt verwendet einen Arduino Uno, einen 7-Segment-LED-Rucksack (I2C), einen HC-SR04-Ultraschallsensor und einen Piezo-Summer. Siehe das Schema unten.

Schritt 2 – Planung und Einrichtung

Über den Schaltplan und die Programmierung hinaus wollte ich mir auch Gedanken über das "fertige Produkt" machen und es nutzbar machen - also in ein Gehäuse packen und dafür planen.

Ich habe ProtoStax-Gehäuse verwendet - sie sind stapelbar und werden mit Unterstützung für Arduino, Raspberry Pi und Breadboard geliefert. Da ich ein Arduino mit einer Breadboard-Schaltung verwendet habe, habe ich mich für das ProtoStax-Gehäuse für Arduino und das ProtoStax-Gehäuse für Breadboard / Custom Boards entschieden. Ich wollte auch, dass der Ultraschallsensor von außen zugänglich und daher am Gehäuse befestigt ist - ich habe das ProtoStax-Kit für den Ultraschallsensor HC-SR04 verwendet.

Ich begann mit dem horizontalen Stapeln der Arduino- und Breadboard-Basisplattformen mit horizontalen Stapelverbindern, um das Prototyping zu erleichtern:

Sobald ich meine Prototyping-Plattform hatte, konnte ich mit dem Bestücken der Komponenten gemäß dem Schaltplan beginnen. Ich habe den Ultraschallsensor HC-SR04 an der Seitenwand des ProtoStax-Kits für Ultraschallsensor HC-SR04 befestigt, um ihn zugänglich zu machen, sobald das Gehäuse nach Fertigstellung des Prototyps zusammengebaut wurde. Die Seitenwand mit dem Sensor geht wie abgebildet in den Schlitz der Grundplattform:

Schritt 3 – Programmieren und Testen

Nachdem ich nun eine funktionierende Prototyping-Plattform hatte, konnte ich den Code dafür entwickeln. Ich werde weiter unten in einem separaten Abschnitt auf die Codefunktionalität und das Layout eingehen. Hier ist ein Video vom Test. Es ist verrückt, dass das iPhone 11, mit dem ich das Video aufgenommen habe, tatsächlich das deutliche Sonarpinging des Ultraschallsensors aufgenommen hat, das im Video unten sehr deutlich zu hören ist (obwohl das Ultraschallpulsen sonst mit einem harmlosen Klick kaum registrierbar ist- Klick klick) !

Nachdem bestätigt wurde, dass alles funktioniert, habe ich die Seitenwände und die restlichen Anschlüsse und Oberteile hinzugefügt, um mein Gehäuse fertigzustellen:

Das Video oben zeigt das endgültige "Produkt" im Einsatz!

Den Kodex verstehen

Initialisieren von Komponenten:

Wir verwenden die Klasse Adafruit_7segment aus der LED-Rucksack-Bibliothek, um unsere 7-Segment-Anzeige zu initialisieren und mit ihr zu kommunizieren.

Adafruit_7segment-Matrix =Adafruit_7segment(); 

Wir initialisieren auch die Trig- und Echo-Pins des HC-SR04 als Ausgang bzw. Eingang

 pinMode(trigPin, OUTPUT); pinMode (echoPin, EINGANG); matrix.begin(0x70); 

In der Hauptschleife wird auf hoher Ebene Folgendes getan:

1) Überprüfen Sie den Abstand des Ultraschallsensors, um zu sehen, ob der Handwasch-Timer ausgelöst wurde.

2) Wenn ja, dann notieren Sie sich die aktuelle Zeit, initialisieren Sie den CountDown-Timer (ich habe ihn für 20 Sekunden auf 20 gestellt) und wählen Sie auch den nächsten Musikjingle zum Abspielen aus. Ich habe zuerst random() verwendet, um eine zufällige Melodie auszuwählen, aber ich habe sie über das Array von Melodien in "Round-Robin" geändert (zurück zur ersten) und startMusic auf 1 gesetzt (um den Countdown und die Musikwiedergabe in Bewegung zu setzen) .

 if (Abstand <10 &&!startMusic) { startMusic =1; // initializeTimer1(); Countdown =20; aktuelleZeit =millis(); melodyNum =(melodyNum+1)%(NUM_MELODIES(melodien)); } 

Schau mal, keine Verzögerung()!

Hier machen wir zwei Dinge gleichzeitig - wir möchten die Countdown-Uhr regelmäßig aktualisieren, die anzeigt, wie viele Sekunden zum Händewaschen noch übrig sind. Wir wollen auch den Jingle verarbeiten und zeitgerecht abspielen.

Wir können nicht Verwenden Sie daher delay().

Das typische Beispiel für das Abspielen von Musik verwendet die Funktion Tone() der Tone-Bibliothek und wartet auf die entsprechende Verzögerung, bevor zur nächsten zu spielenden Note übergegangen wird. Das wird nicht funktionieren, da wir die Countdown-Uhr noch aktualisieren wollen!

tone() ist ein nicht blockierender Aufruf. Es verwendet den Timer2, um das Signal für die angegebene Zeitdauer zu senden, was bedeutet, dass wir in der Zwischenzeit andere Verarbeitungen vornehmen können.

Wir verwenden millis() und lokale Variablen, um herauszufinden, wie viel Zeit verstrichen ist, anstatt delay() zu verwenden, und können in der Zwischenzeit andere Prüfungen und Operationen durchführen. Wir werden uns den genauen Code etwas weiter unten ansehen.

Musik ganz einfach transkribieren – ganze Noten, Viertelnoten usw.

Wir möchten eine bestimmte Melodie spielen und es einfach machen, weitere Melodien zu transkribieren. Arduino-Musikbeispiele speichern normalerweise zwei verschiedene Arrays, eines für die Noten und ein Array für die Dauer der Noten (in Millisekunden).

Um die Dinge zu vereinfachen, habe ich eine Struktur erstellt, um eine Note und ihre gegebene Dauer zu verknüpfen. Und anstatt absolute Dauern zu verwenden, habe ich relative Dauern verwendet, für die ich #defines erstellt habe

typedef struct Hinweis { int frequency; Float-Dauer; } Note;#define NOTE_WHOLE 1#define NOTE_HALF 0.5f#define NOTE_QUARTER 0.25f#define NOTE_EIGHTH 0.125f#define NOTE_SIXTEENTH 0.0625f#define PUNKT(X) (X * 1.5f)  

Nehmen wir das Beispiel Happy Birthday.

Dies kann wie folgt transkribiert werden, ziemlich viel Note für Note. Wenn Sie keine Noten lesen können, suchen Sie einfach nach den tatsächlichen Noten. 🤓📚Aber Noten lesen zu lernen ist immer eine nette Fähigkeit, die man haben muss, und Sie müssen nicht sehr gut darin sein - gerade genug, um die Noten zu kennen, ermöglicht es Ihnen, das Notwendige zu tun, um die Noten auf Ihre zu transponieren Arduino!

// Happy BirthdayNote melody[] ={ {NOTE_G6, DOTTED(NOTE_EIGHTH)}, {NOTE_G6, NOTE_SIXTEENTH}, {NOTE_A6, NOTE_QUARTER}, {NOTE_G6, NOTE_QUARTER}, {NOTE_C7, NOTE_QUARTER}, { .NOTE_C7, NOTE_QUARTER}, { .NOTE_C7, NOTE_QUARTER} , NOTE_HALF}, {NOTE_G6, DOTTED(NOTE_EIGHTH)}, {NOTE_G6, NOTE_SIXTEENTH}, {NOTE_A6, NOTE_QUARTER}, {NOTE_G6, NOTE_QUARTER}, {NOTE_D7, NOTE_QUARTER}, {NOTE_C7, NOT_HALF(G), {NOTE_HALF(G), {NOTE_HALF(G) }, {NOTE_G6, NOTE_SIXTEENTH}, {NOTE_E7, NOTE_QUARTER}, {NOTE_D7, NOTE_QUARTER}, {NOTE_C7, NOTE_QUARTER}, {NOTE_B6, NOTE_QUARTER}, {NOTE_A6, NOTE_HALF}, {NOTE_F7,_NOT NOTE_SIXTEENTH}, {NOTE_E7, NOTE_QUARTER}, {NOTE_C7, NOTE_QUARTER}, {NOTE_D7, NOTE_QUARTER}, {NOTE_C7, NOTE_HALF}, }; 

Beachten Sie (Wortspiel beabsichtigt!), dass ich hier keine tatsächlichen Dauern verwendet habe, ich habe die relative Dauer der Noten als Viertelnoten, Achtelnoten, Sechzehntelnoten usw. angegeben. Ich habe sogar ein DOTTED()-Makro, um eine punktierte Note darzustellen (1,5 x die Dauer der Note, die ihr vorausgeht).

Eine Melodie selbst besteht aus diesem Array, sowie zusätzlichen Informationen darüber, welche Dauer eine ganze Note darstellen soll.

typedef struct Melodie { Note *notes; int numNotizen; int ganzNoteDurationMs; } Melodie; 

Da die Größe von C-Arrays nicht mit einem Zeiger auf das Array geändert werden kann, füge ich die numNotes als Größe des Note-Arrays hinzu. Dies kann ganz einfach mit dem MELODY_LENGTH-Makro initialisiert werden - Sie müssen sich also keine Gedanken darüber machen, wie viele Noten Sie in Ihrem Noten-Array erstellt haben, als Sie Ihr Lieblingslied transkribiert haben!

Ich definiere dann ein Array solcher Melodien, um sie in meinem Programm zu verwenden.

Melodiemelodien[] ={ {melody, MELODY_LENGTH(melody), 1250}, {melody3, MELODY_LENGTH(melody3), 1000}, {melody4, MELODY_LENGTH(melody4), 1000}}; 

In der Schleife verwende ich beim Starten des CountDown-Timers und der Musik die obigen Informationen zu Noten, relativen Dauern und der tatsächlichen Dauer einer ganzen Note, um herauszufinden, wie die Musik gespielt wird. Zwischen dem Abspielen der Musik überprüfe und aktualisiere ich auch den CountDown-Timer und zeige die Zahl auf der 7-Segment-Anzeige an.

Da ich mir vorstelle, dass die Leute gerne den ganzen Jingle zu Ende hören möchten, spiele ich den Jingle bis zum Ende weiter, auch wenn die 20 Sekunden abgelaufen sind (der CountDown wird negativ, bis der Song endet). Sobald der Jingle beendet ist, stoppt er, bis er durch erneutes Winken mit der Hand vor dem Ultraschallsensor weiter ausgelöst wird. Wenn der Jingle zu kurz ist, wird er noch einmal abgespielt, bis 20 Sekunden vergangen sind UND die Musik zu Ende ist! Einfach.

 if (startMusic) { // Wählen Sie die Melodie zum Abspielen aus Melody mel =melodies[melodyNum]; Anmerkung *m =Mel.Noten; int mSize =mel.numNotes; // speedUp ist eine einfache Möglichkeit, das Spielen der Noten zu beschleunigen. Der beste Weg wäre, // die WholeNoteDurationMs entsprechend einzustellen. int speedUp =1; kein Ton (TONE_PIN); // Beginnen Sie mit einer leeren Tafel für (int thisNote =0; thisNote