Touchless Musical Hand Wash Timer

Over dit project

Hoewel handen wassen altijd een belangrijk arsenaal is geweest op het gebied van ziektepreventie en algehele gezondheid, heeft het een nieuwe bekendheid gekregen als preventieve maatregel om de verspreiding van de COVID-19-pandemie in te dammen.

De CDC-richtlijn voor goed handen wassen stelt dat men de handen idealiter 20 seconden moet schrobben. https://www.cdc.gov/handenwassen/wanneer-hoe-handenwassen.html

🤓📚** Extra dingen ** 🤓📚 Hier is een deel van de wetenschap achter handen wassen als je geïnteresseerd bent! - https://www.cdc.gov/handwashing/show-me-the-science-handwashing.html

In deze redux van een handwastimer wordt onze muzikale handwastimer geactiveerd door met onze hand voor een ultrasone sensor te zwaaien, en het aftellen wordt weergegeven op een 7-segments display. Om het interessanter te maken, speelt het ook een roterende selectie van jingles van 20 seconden uit een lijst met voorgeprogrammeerde jingles. Je kunt eenvoudig je eigen muziek toevoegen door elke bladmuzieknotatie die je hebt te transcriberen!

Hier is een blik op de Touchless Musical Handwastimer in actie, met alle 4 jingles die ik heb geprogrammeerd in

• Gefeliciteerd

• Do-Re-Mi (Sound of Music)

• We Will Rock You (Queen)

• Jeopardy-themamuziek

Tjonge, mijn handen waren super-duper schoon aan het einde van het!

🤓📚** Extra dingen ** 🤓📚We weten inmiddels allemaal dat het twee keer zingen van "Happy Birthday to You", ongeveer 20 seconden duurt, en het is een de facto standaard geworden voor de timing van het handen wassen, zelfs gezongen door de Canadese premier Justin Trudeau! Dr. Theresa Tam, Canada's Chief Public Health Officer, heeft haar eigen favorieten zoals We Will We Will Wash You ! 😊Bekijk dit fascinerende interview hieronder door CBC Kids News-medewerker Arjun Ram.

Ik gebruik beide nummers in onze Touchless Musical Hand Wash Timer , plus nog een paar!

Stap 1 - Schematisch

Dit project maakt gebruik van een Arduino Uno, een 7-segment LED-rugzak (I2C), een HC-SR04 ultrasone sensor en een piëzo-zoemer. Raadpleeg het onderstaande schema.

Stap 2 - Plannen en opzetten

Naast de schema's en de programmering, wilde ik ook nadenken over het "afgewerkte product" en hoe het bruikbaar te maken - daarom het in een behuizing plaatsen en daarvoor plannen.

Ik gebruikte ProtoStax-behuizingen - ze zijn stapelbaar en worden geleverd met ondersteuning voor Arduino, Raspberry Pi en Breadboard. Omdat ik een Arduino met een Breadboard-circuit gebruikte, koos ik voor ProtoStax Enclosure voor Arduino en ProtoStax Enclosure voor Breadboard/Custom Boards. Ik wilde ook dat de ultrasone sensor van buitenaf toegankelijk was en daarom aan de behuizing werd bevestigd - ik gebruikte de ProtoStax-kit voor ultrasone sensor HC-SR04.

Ik begon met het horizontaal stapelen van de Arduino- en Breadboard-basisplatforms met behulp van horizontale stapelconnectoren om prototyping te vergemakkelijken:

Toen ik eenmaal mijn prototyping-platform had, kon ik beginnen met het vullen van de componenten volgens het schema. Ik heb de HC-SR04 ultrasone sensor aan de zijwand van de ProtoStax-kit voor ultrasone sensor HC-SR04 bevestigd om deze toegankelijk te maken zodra de behuizing in elkaar was gezet nadat het prototype voltooid was. De zijwand met de sensor gaat zoals afgebeeld in de gleuf van het basisplatform:

Stap 3 - Programmeren en testen

Nu ik een werkend prototypeplatform had, kon ik de code ervoor gaan ontwikkelen. Ik zal meer ingaan op de codefunctionaliteit en lay-out in een apart gedeelte hieronder. Hier is een video van het testen. Het is bizar dat de iPhone 11 die ik heb gebruikt voor het opnemen van de video, het duidelijke sonar-pingen van de ultrasone sensor heeft opgepikt, wat heel duidelijk te horen is in de onderstaande video (hoewel het ultrasone pulseren nauwelijks te registreren is met een onschuldige klik- klik-klik)!

Nadat was bevestigd dat alles werkte, ging ik verder en voegde de zijwanden en de resterende connectoren en bladen toe om mijn behuizing af te werken:

De video bovenaan toont het uiteindelijke "product" in gebruik!

De code begrijpen

Componenten initialiseren:

We gebruiken de Adafruit_7segment-klasse uit de LED-rugzakbibliotheek om ons 7-segments display te initialiseren en ermee te communiceren.

Adafruit_7segment matrix =Adafruit_7segment(); 

We initialiseren ook de trig- en echo-pinnen op de HC-SR04 als respectievelijk output en input

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

In de hoofdlus is dit wat er op hoog niveau wordt gedaan:

1) Controleer de afstandsmeting van de ultrasone sensor om te zien of de handwastimer is geactiveerd.

2) Zo ja, noteer dan de huidige tijd, initialiseer de countDown-timer (ik stel deze in op 20 voor 20 seconden) en kies ook de volgende muzikale jingle om te spelen. Ik gebruikte eerst random() om een ​​willekeurige melodie te kiezen, maar ik veranderde het in "round-robin" over de reeks melodieën (terug fietsend naar de eerste), en zette startMusic op 1 (om het aftellen en het afspelen van muziek in te stellen

 if (afstand <10 &&!startMusic) { startMusic =1; // initializeTimer1(); aftellen =20; huidigeTijd =millis(); melodyNum =(melodyNum+1)%(NUM_MELODIES(melodieën)); } 

Kijk ma Geen vertraging()!

Hier doen we twee dingen tegelijk - we willen de aftelklok regelmatig bijwerken om te laten zien hoeveel seconden er nog over zijn om de handen te wassen. Ook willen we de jingle verwerken en op tijd correct afspelen.

Wij kunnen niet gebruik daarom delay().

Het typische voorbeeld van het afspelen van muziek maakt gebruik van de tone()-functie van de Tone-bibliotheek en wacht op de juiste vertraging voordat hij doorgaat naar de volgende te spelen noot. Dat gaat niet werken, omdat we de aftelklok nog steeds willen updaten!

tone() is een niet-blokkerende oproep. Het gebruikt de Timer2 om het signaal voor de opgegeven tijdsduur te verzenden, wat betekent dat we in de tussentijd vrij zijn om andere verwerkingen uit te voeren.

We gebruiken millis() en lokale variabelen om erachter te komen hoeveel tijd er is verstreken, in plaats van delay(), en kunnen in de tussentijd andere controles uitvoeren en andere bewerkingen uitvoeren. We zullen de exacte code iets verderop bekijken.

Muziek transcriberen op de gemakkelijke manier - hele noten, kwartnoten, enz.

We willen een bepaalde melodie spelen en het ook gemakkelijk maken om meer melodieën te transcriberen. Arduino-muziekvoorbeelden slaan meestal twee verschillende arrays op, één voor de noten en één array voor de duur van de noten (in milliseconden).

Om dingen te vereenvoudigen, heb ik een structuur gemaakt om een ​​notitie en de gegeven duur te associëren. En in plaats van absolute duur te gebruiken, gebruikte ik relatieve duur die ik heb gemaakt #defines voor

typedef struct Opmerking { int frequentie; vlotterduur; } Opmerking;#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 DOTTED(X) (X * 1.5f)  

Laten we het voorbeeld nemen van Happy Birthday.

Dit kan als volgt worden getranscribeerd, vrijwel noot voor noot. Als u geen bladmuziek kunt lezen, zoekt u gewoon de daadwerkelijke noten die u wilt gebruiken. 🤓📚Maar bladmuziek leren lezen is altijd een leuke vaardigheid om te hebben, en je hoeft er niet erg goed in te zijn - net genoeg om te weten wat de noten zijn, kun je het nodige doen om de muziek naar je Arduino!

// Gefeliciteerd met je verjaardagNote-melodie[] ={ {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_B6, {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, NOTE_HALFE6, {NOTE_HALF} }, {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_NOTE_IGHTNOTED,} NOTE_SIXTEENTH}, {NOTE_E7, NOTE_QUARTER}, {NOTE_C7, NOTE_QUARTER}, {NOTE_D7, NOTE_QUARTER}, {NOTE_C7, NOTE_HALF}, }; 

Merk op (bedoelde woordspeling!) dat ik hier geen werkelijke duur heb gebruikt, ik heb de relatieve duur van de noten gespecificeerd als kwartnoten, achtste noten, zestiende noten, enz. Ik heb zelfs een DOTTED()-macro om een ​​gestippelde noot weer te geven (1,5 x de duur van de noot die eraan voorafgaat).

Een melodie zelf bestaat uit deze array, evenals aanvullende informatie over de duur van een hele noot.

typedef struct Melody { Opmerking *notes; int numOpmerkingen; int wholeNoteDurationMs; } Melodie; 

Omdat de grootte van C-arrays niet kan worden aangepast door een aanwijzer naar de array te gebruiken, voeg ik de numNotes toe als de grootte van de Note-array. Dit kan eenvoudig worden geïnitialiseerd met behulp van de MELODY_LENGTH-macro - dus u hoeft zich geen zorgen te maken over hoeveel noten u in uw notenarray hebt gemaakt terwijl u uw favoriete nummer transcribeert!

Vervolgens definieer ik een reeks van dergelijke melodieën om in mijn programma te gebruiken.

Melodiemelodieën[] ={ {melodie, MELODY_LENGTH(melodie), 1250}, {melody3, MELODY_LENGTH(melody3), 1000}, {melody4, MELODY_LENGTH(melody4), 1000}}; 

In de loop, wanneer ik de countDown-timer en de muziek start, gebruik ik de bovenstaande informatie over noten, relatieve duur en de werkelijke duur van een hele noot om erachter te komen hoe de muziek moet worden afgespeeld. Tussen het afspelen van de muziek door controleer en update ik ook de countDown timer en geef ik het nummer weer op het 7-segment display.

Omdat ik me kan voorstellen dat mensen graag naar de hele jingle zouden willen luisteren, speel ik de jingle door tot het einde, zelfs als de 20 seconden voorbij zijn (het aftellen wordt negatief totdat het nummer eindigt). Zodra de jingle is afgelopen, stopt deze totdat deze verder wordt geactiveerd door nogmaals met uw hand voor de ultrasone sensor te zwaaien. Als de jingle te kort is, wordt deze opnieuw afgespeeld, totdat er 20 seconden zijn verstreken EN de muziek is afgelopen! Gemakkelijk.

 if (startMusic) { // Kies de melodie om af te spelen Melody mel =melodieën [melodyNum]; Opmerking *m =mel.notes; int mSize =mel.numNotes; // speedUp is een gemakkelijke manier om het spelen van de noten te versnellen. De beste manier zou zijn om // de wholeNoteDurationMs op de juiste manier in te stellen. int speedUp =1; geen toon (TONE_PIN); // Begin met een schone lei voor (int thisNote =0; thisNote  

De volledige code is te vinden op GitHub en de link naar de repository is inbegrepen. Ik zou aanraden de code vanaf daar te nemen, in plaats van de code vanaf hier te kopiëren en te plakken.

Het project verder brengen

Als je eenmaal vertrouwd bent geraakt met het spelen met het codevoorbeeld en de code begrijpt, is het altijd leuk om te proberen je kennis uit te breiden door meer te doen.

Hier zijn een paar suggesties over hoe u dit project vooruit kunt helpen:

1) Je kunt je favoriete deuntje vinden en het vervolgens transcriberen met de OPMERKING en OPMERKING duur macro's zoals ik hierboven heb beschreven. Vergeet niet om commentaar te geven op een of meer van de andere jingles die al zijn gedefinieerd, om het geheugengebruik laag te houden (tenzij u doorging en de noot- en melodiearrays met succes naar PROGMEM verplaatste, zoals hieronder beschreven! 😊)

2) De melodieën nemen ruimte in beslag in het SRAM en kunnen heel snel het beschikbare geheugen opeten. Ik heb bijvoorbeeld 4 melodieën getranscribeerd (Happy Birthday, Do-Re-Mi, We Will Rock You en Jeopardy!). Deze stuwden het SRAM-gebruik echter naar 96%, waardoor er niet genoeg overbleef voor het functioneren van de 7-segments display-bibliotheek, en het werd niet goed geüpdatet! Ik moest een van de melodieën uitsluiten van de Melody-array om alles goed te laten werken.

De Arduino Uno wordt geleverd met 2k SRAM, maar 32k Flash-geheugen (waar het programma zich bevindt). Als je enkele van de globale variabelen naar Flash-geheugen kunt verplaatsen, kun je niet alleen SRAM vrijmaken voor de rest van het programma, maar heb je ook meer ruimte om nog meer nummers op te slaan! Probeer de noot- en melodiearrays naar Flash te verplaatsen door ze te definiëren als PROGMEM. [Opmerking:dit is een geavanceerde onderneming en niet triviaal. Jij zal wees degraderen de matrix van struct naar PROGMEM en dan hebben naar lees de programma naar toegang de gegevens.]

Om je een idee te geven van de verschillen, nam dit programma (met 3 melodieën) 31% van de programmaopslag en 76% van het dynamisch geheugen in beslag op een Uno. Met de bovenstaande variabelen gedefinieerd in PROGMEM, nam het 32% van de programmaruimte in beslag (dat is slechts een kleine toename van het gebruik van Flash-geheugen en er is nog veel meer beschikbaar) en slechts 22% (tegenover 76%) van het dynamisch geheugen! Dat betekent dat je gemakkelijk veel . kunt toevoegen nummers op deze Touchless Musical Hand Wash Timer zodra u dingen naar PROGMEM!

Kun je andere manieren bedenken om dit project uit te breiden? Deel het hieronder met ons!

Veel plezier met maken!

Code

ProtoStax Touchless Muzikale Handwas Timer Demo

ProtoStax Touchless Musical Handwash Timer Demohttps://github.com/protostax/ProtoStax_Touchless_Musical_Handwash_Timer

Schema's

Dit toont het schema voor het circuit dat wordt gebruikt in de afteltimer van de Touchless Musical Hand Wash