Lucy’s Status Report for 3/30

What did you personally accomplish this week on the project? Give files or photos that demonstrate your progress. Prove to the reader that you put sufficient effort into the project over the course of the week (12+ hours)

This week, I continued working on the web app. I familiarized myself with Firebase and watched a few tutorials on how to use the database and connect it with react native. I spent some time researching how to use it effectively and build the app backend.

For our project, we need to constantly read in mic values, update the database, and display the decibel readings onto the web app. Since we required our latency to be no more than one second between the sound and the readings on the bracelet and web app, I have been looking into ways to make this work. I seem to be having trouble figuring out how to continuously read and update the app page with a constantly updating database, so I have to do more research on this.

Katherine has created csv files with preliminary input data from the bracelet mics. To start, I have been using these files as the “data” in the database and testing to see if they can be displayed correctly on the web app. I have been looking into ways to read in the csv files and display the proper data onto the web app readings page. If this works, it will at least prove that we are able to get data from the mic readings onto the app. I’m not sure how viable this approach would be once we add in bluetooth connection and the database, but it’s a start.

Additionally, I have started building the settings page for the web app. This is the page where the user can switch between bracelet modes and customize the bracelet. 

Is your progress on schedule or behind? If you are behind, what actions will be taken to catch up to the project schedule?

Should be on schedule right now, apart from bluetooth connection and the visualizations page. Since the visualizations page requires data and I haven’t quite set that up yet, I can’t get the actual graphs to work. The frontend for the page should is done though. Once bluetooth is working, I think I’ll have a better understanding on how data transmission to and from the web app will be like.

What deliverables do you hope to complete in the next week?

With the interim demo in a few days, I hope to have most of the screens of the web app polished up. I plan to show the authentication mechanism, the frontend of the app, and that the app can display the csv input data.

Katherine’s Status Report for 3/30

This week, I used this pySerial tutorial (https://www.instructables.com/Capture-Data-From-Arduino-to-CSV-File-Using-PySeri/) to update the microphone testing code to save input data to a CSV file. These resources were helpful: https://forum.arduino.cc/t/compilation-error-read-econnreset/1114185, https://www.developer.com/languages/python/map-event-codes-python/. I also put together a test circuit (with Zeynep’s help) to confirm that the bracelet hardware can run entirely off of the battery as planned in the circuit diagram. Thank you, Freda, for suggesting these tasks!

Some of my deliverables from last week are behind schedule. However, the context and importance of some of these deliverables has changed.

Microphone signal processing is done (with Freda’s help) in the sense that microphone inputs can be obtained and used to affect other components like the LEDs. However, further improvement/debugging is needed. For example, I need to look into increasing the speed at which the Beetle runs so that microphone input can catch higher-frequency inputs such as those expected from piano or higher voices. This resource is useful for determining which frequencies correspond to notes we want to catch: https://www.omnicalculator.com/other/note-frequency.

In testing, we are not currently scaling microphone input values to correspond to decibel meter readings. It seems like the scale value varies among microphones, so the best thing to do might be to wait until we have assembled the final hardware components on the flex PCB before tuning the scale values. Similarly, the microphone testing code does not currently average samples over time. Although it is not correct for our final product to register short noises like tapping near the microphone, it is useful in testing. Also, as long as we are not weighting the input based on frequency, it is likely not necessary to perform an FFT for determining the dB value.

Visualization of decibel readings was not complete by March 30th; it is likely that this will be completed after the interim demo.

Some testing of the device has begun. It is not possible to complete the timeliness test now, because the webapp and device are not yet integrated. Similarly, since the bracelet is not assembled, passing the heat test has not happened yet. We are attempting to improve the accuracy of the microphone, but its results do not yet correspond to dB meter readings.

Deliverables for next week include placing an order for plastic wrap, helping bring the hardware subsystem (microphones and LEDs) to a testable state, and testing it in music studio sessions.

Team Status Report for 3/30

Currently, the greatest risk is that we will not be able to extract usable data from the microphones. If this is because the microphone doesn’t react to any sound input as proven on the oscilloscope (likely incorrectly soldered), we can repeat the assembly/soldering process with more components. If the microphone reacts to oscilloscope testing but not to the microphone testing program that prints to the serial monitor, further microphone testing is required to determine the source of the issue. If the microphone reacts to environment sound but the data we receive does not directly correspond to what we expect, we need to continue signal processing to calibrate the data.

We need to have the hardware aspects mostly complete by Tuesday (the first music testing session of the week) and the webapp subsystem mostly complete by Wednesday (interim demo day).

Since last time, we tested the microphones and LEDs on each board to find out which boards have which functioning. We also tested a program that would change the LED color if the microphone input exceeded a certain threshold. Webapp research about the database and file format continues. Also, we now have a decibel meter! This will provide a baseline against which we can measure the bracelet results.

We haven’t changed the design of the system.

The Gantt chart has been updated:

  • The interim demo is now scheduled for Wednesday, April 3rd.
  • Database, visualization, customization is due Friday, April 6th.
  • Timeliness/accuracy/heat tests are also due April 6th.

Clapping demo

Caption: The lights change color to red and back to yellow very fast, so if you want to see it better, change the video speed to 0.25, and focus on 0:02 to 0:04.

Also available on YouTube: https://youtube.com/shorts/fKVRntFnD_Q

Freda’s Status Report for 3/30

What did you personally accomplish this week on the project? Give files or photos that demonstrate your progress. Prove to the reader that you put sufficient effort into the project over the course of the week (12+ hours)

I solved a few problems mentioned in the previous status report.

  1. Nothing prints in the Serial Monitor: in Arduino, go to Tools -> USB CDC On Boot “Enabled”. If “Disabled”, nothing prints.
  2. Beetle connection isn’t recognized/won’t upload code: often, when I switch out a Beetle and/or data cable (we have 2 of each), the upload process will fail. Sometimes it fails because the port is grayed out and won’t allow you to connect, or sometimes it’ll say some Serial data error. Here are solutions I do to fix this:
    • Unplug/replug Beetle, restart Arduino/computer
    • Spam the Beetle buttons for boot/reset during compilation. You should hear the USB connect/disconnect sounds if your computer has those. It might not work the first time, but eventually you get the timing right and it’ll finally agree to upload. I usually do the blink test for this, since it’s pretty easy to tell if it worked. If the Arduino IDE says “upload successful”, but you still don’t see any light, click the reset button once (right button), and then the light should start blinking.
  3. Lights not lighting up: at first we thought it was the Polulu boost converter not boosting our voltage to 5V correctly, because we triple checked all our connections and they looked correct. So the next solution was to find a 5V supply directly and skip the Polulu middle-man. Techspark has some of those, so after connecting the Beetle to common ground, as soon as the 5V probe touched the V_regulator pin I set up, we were treated to a glorious array of wonderful colors! They were bright and rainbow and all we could’ve ever hoped for!*

*We actually were hoping that all the boards would have working lights, but when we tested boards 3 and 4, there was no reaction from applying the 5V. It’s pretty strange, since the Neopixels are bigger and thus easier to place and solder correctly compared to the mics. We also placed all the Neopixels in the same orientation, so wrong connections shouldn’t be an issue. Our success rate for lights is 3 out of 5 boards, so 60%.

Turns out, it was just a poor connection issue with the Polulu, because if you press on the boost converter at a certain angle, the lights will turn on. We also transferred all our wiring to header pins/breadboard connections to be more stable instead of just floating around. We will be soldering it on for the final product, so that won’t be an issue. We’re just hesitant to solder things on now because things aren’t finalized and soldering is a pain to undo.

Light video

After that, we tested all the mics with Prof Fedder’s tutelage. He explained that the mics DC voltage was around half of our power supply of 3.3V (so about 1.1V). So we first use the oscilloscope to measure our mic output pins to see if we get anywhere in that range. (Unfortunately, we can’t check the mic pins directly because they’re SMD, and thus directly under the mic.) Once we have a confirmed reasonable voltage (the bad mics register voltage levels in the mV), we move on to AC voltage. The test here is to play a tone near the mic and test different distances: we should see the amplitude of the sine wave on the oscilloscope change accordingly. For the non-working mics, we just saw “noise”.

Since the mics are so tiny, it’s very hard to apply solder on them to balance between falling off from not enough solder, or shorting all the connections because the solder reflow was too much. During the PCB assembly, we tried 2 methods; on the left side (mostly likely) of each board, Lucy applied a bit of extra solder manually to help the mics stick better. On the right side, I set the mics with just the initial amount of solder that made it through the solder mask. Here are the results for the boards’ mics that made the cut.

1: both mics work

2: right mic only

3: right mic only

4: left mic only

5: neither

It looks like the right mic technique may have had a bit of a slight advantage over the left mic, but honestly since the sample size is so small I’m not sure we can derive statistical significance from this. The survival rate of mics is 50%, but if we want both mics to work, the survival rate drops to 20%.

Since LED survival rate is 60%, the overall board success rate would be 30% if optimistic, and 12% if not optimistic (multiplying the survival rates because “and” condition). So optimistically we’ll need to build 4 boards, and non optimistically, 10 (expected value math). Then we apply backup calculations by doubling these amounts to get 8 or 20 boards. They will probably all cost the same amount so it’s not much of a cost thing as it is more of a “we need to make sure we have enough of the other components”. For example, our LEDs deplete the fastest since there’s 6 per board. We used up 30 of them for the prototype boards, so we have 70 left in our pack. If we are optimistic, we would have enough if we built 8 boards, but not enough if we want to build 20 boards. Prof Fedder gave us more microphones and says he has many more, so that probably won’t be our limiting factor. We also grabbed a bunch of the SMD resistors and capacitors, and only use like, 2 per board so we should be good there too.

Then was the music recording session where, for the first time, we had both the professional decibel meter and our own DIY mics (uncalibrated). Hopefully, we would see some trends between them so we could have an idea of what kind of math is needed to calibrate our mics. I used board 1, since we established that both mics were supposed to work, and put the decibel meter and board right next to each other on the music stand in the middle between the piano and singer. Observations:

  • FAST, Lo, dbA settings: during ambient noise, it’s pretty close (both in the 40’s), but when music starts, the professional mic picks up the noise way better than the board mics; think i spotted around 60 on the board mic when I moved it closer, which is still less than the 70s to 80s that the decibel meter says.
  • FAST, Hi, dbC settings: ambient now around 60 on the decibel meter instead of 40, and music is around 80s to 90s. Board values still stay around the same range as last time though.
  • Something a bit concerning: the left mic seems to be more sensitive and goes up to 60, but the right mic stays solidly at 48-49 the whole time, even though both of them are supposed to work and I assumed they’d be around the same sensitivity level? They have the same resistors at least. The left mic is closer to the singer, the right mic is closer to the piano, but that shouldn’t make that much of a difference? Maybe the decibel meter mic was nearer to the right mic which may affect things.

The code was sampling with delays at this point so we’d know the sampling frequency exactly. Later we just got rid of the delay to sample as fast as possible, and based on the timestamped CSV logs, it calculated about 1200 readings per second, which is abysmally slow compared to the range that singers and pianists use. So perhaps that’s why the mic readings were suffering from such a limited range/sensitivity during the music session. Katherine can tell you more about her plans for fixing this in her section.

Is your progress on schedule or behind? If you are behind, what actions will be taken to catch up to the project schedule?

Amazingly, I have actually finished all my tasks on time for once! I also have code that changes the color of lights based on mic readings. Since the mics are uncalibrated, the thresholds are bogus, but as a proof of concept, you can see the video in the team report where clapping changed the light color from yellow to red. We could add gradient colors to interpolate smoothly between the yellow and red (orange) through HSV conversions to show the user more precision in the readings instead of just “buckets”, but when we were testing, we noticed the lights were sometimes flashing between yellow and red so quickly that it looked orange already due to persistence of vision, so perhaps gradient is unnecessary and we can keep the code simple.

What deliverables do you hope to complete in the next week?

I can try physical fabrication of the bracelet with the hard PCB, just to have some practice. Perhaps I’ll run into surprise issues that I didn’t know were going to be a thing. In particular, since our plastic sheet got lost to the void, we only have plastic tubing right now, so I can experiment with how viable of an option that is or if we really need the plastic sheet instead. We can also test how much the mics are affected by being in plastic; although depending on how noisy the uncalibrated data is, I’m not sure if we’ll be able to derive meaningful results if testing uncalibrated.

Katherine’s Status Report for 3/23

This week, I wrote and tested out a program that relates microphone input values to dB values (multiplying/dividing input by a constant) on the PCB. I can get a Serial Monitor reading of the left and right microphone values that has approximately the right magnitude when the input from each microphone is scaled down by 10.

Unexpectedly, using no resistor (open) in the spaces meant for the gain resistor on the analog microphones returns reasonable values. The values returned are on the order of the values for minimal resistance (when the space for the gain resistor is occupied by a wire).

This photo shows sample results from the microphones without any resistor.

This photo shows sample results from the microphones when they have a gain connection of minimal resistance (wire).

Progress was technically behind on microphone signal processing, the Bluetooth-webapp connection, and visualization of decibel readings. Microphone signal processing is now expected to be complete by this Friday. Bluetooth is most relevant to webapp-device integration, and can be addressed after the interim demo. However, it might be useful to continue searching for resources/information if other tasks are completed early. Visualization of decibel readings is expected to be complete before March 30th.

Bluetooth research proceeded. I attempted to go through the steps of the Bluno basic demo (https://wiki.dfrobot.com/Bluno_Beetle_SKU_DFR0339, https://wiki.dfrobot.com/Bluno_SKU_DFR0267#Bluno_Basic_Demo, troubleshooting information https://wiki.dfrobot.com/Bluno_SKU_DFR0267#target_7, https://support.arduino.cc/hc/en-us/articles/6554914611228-Compilation-error-exit-status-1), under the assumption that it would be fairly similar to the Beetle’s BLE system. I was unsuccessful. However, I was able to install the APK on my phone and look at the names of Bluetooth devices in the area (resources: ttps://www.lifewire.com/install-apk-on-android-4177185, https://www.softwaretestinghelp.com/how-to-open-apk-file/, https://support.google.com/googleplay/thread/56676897/how-do-i-install-3rd-party-apps-and-apk-files-on-my-motorola-g-stylus?hl=en). I looked at these resources (https://www.arduino.cc/reference/en/libraries/arduinoble/, https://www.arduino.cc/reference/en/language/functions/communication/serial/println/) when trying to debug the code; it printed an error reading “controller lib commit: [77d09ce]”. This error apparently stems from a conflict between the ESP32-C6 module and the main controller module (https://github.com/h2zero/NimBLE-Arduino/issues/645). It seems like we would have to change how the Bluetooth module and the Beetle interact with each other in order to fix this problem.

Most of my tasks this week will focus on microphone signal processing. I’m going to tune the scale that determines output values: gather microphone data from an established sound, measure the sound dB externally, and improve the microphone results by adjusting the scale value to better match the external measurement (thank you, Freda, for suggesting this experiment). I would also like to graph some portion of these results (both from the external measurements and the microphones’ measurements).

For Friday, I intend to update the microphone signal processing code to:

Take multiple samples per second and average or otherwise combine them in order to account for external noise not relevant to the user (for example, tapping the device near a microphone location).

Use an FFT (https://en.wikipedia.org/wiki/Fast_Fourier_transform) like https://projecthub.arduino.cc/abhilashpatel121/easyfft-fast-fourier-transform-fft-for-arduino-03724d to define dB value as based on the highest amplitude of the highest relevant frequency in the microphone input, and use Serial Plotter to visualize the frequency results.

This week, I also intend to participate in timeliness, accuracy, and heat tests for the hardware components of the bracelet.

Lucy’s Status Report for 3/23

What did you personally accomplish this week on the project? Give files or photos that demonstrate your progress. Prove to the reader that you put sufficient effort into the project over the course of the week (12+ hours)

This week, Freda and I spent some time assembling the PCBs. It took a while to get the soldering mask aligned properly since the we had so many small components. Additionally, we ran into a small delay since some of the SMD components we were hoping to use were not restocked. I messed up soldering one of the header pins onto  one of the PCB boards and it took a bit of time to desolder it, but everything worked out fine in the end.

Also, I spent some time starting the backend of the web app. For now, we are pushing bluetooth connection until after the interim demo to give us more time to focus on other features. The goal now is to get the database readings working on the app by the end of next week to demo. For now, we are using Firebase because it is a real time database with a free plan that can suit our needs.

Is your progress on schedule or behind? If you are behind, what actions will be taken to catch up to the project schedule?

I am slightly behind since the bluetooth integration on the web app is still not done yet. That has been pushed back to allocate more time for the backend of the web app.

What deliverables do you hope to complete in the next week?

Since the interim demo is in one week, I am prioritizing getting as many features of the web app completed as possible. The integration with the bracelet will have to wait. The plan is to have web app and  bracelet working separately by April 1st (demo day), with integration and bluetooth connection happening the week afterwards.

Team Status Report for 3/23

This week, we received and put together the PCB prototypes, started code for the bracelet, and worked on the webapp.

  • What are the most significant risks that could jeopardize the success of the project? How are these risks being managed? What contingency plans are ready?

One risk is that the plastic wrap still hasn’t come in, so the interim demo bracelet might need to be fabricated entirely out of plastic tubing or have no plastic covering. The casing isn’t a major subsystem, so we should be fine without casing for the interim demo anyways. BLE setup/interfacing is also challenging, but will be addressed after the interim demo when integrating the bracelet and web app.

  • Were any changes made to the existing design of the system (requirements, block diagram, system spec, etc)? Why was this change necessary, what costs does the change incur, and how will these costs be mitigated going forward?

No changes were made to the existing design of the system. Soon after the interim demo, we may consider changing requirements or other design elements if feedback suggests that it would benefit the system.

  • Provide an updated schedule if changes have occurred.

The Gantt chart has been updated to reflect that complete (separate) subsystems of the physical bracelet and webapp are due April 1st (interim demo).

  • This is also the place to put some photos of your progress or to brag about a component you got working.

Isn’t it beautiful? Let’s hope it actually works.

Freda’s Status Report for 3/23

The PCBs finally came in this week, so Lucy and I were able to assemble them in the PCB lab and hand solder on the rest.

A few takeaways: because everything is so small, the solder mask took a while to line up precisely, and we weren’t sure if there would be enough solder on the smallest component (microphones) to stick, but luckily it did. Another thing that was tricky was looking closely at the mics and LEDs since those have directionality in placing them. We are relatively sure we got the mics oriented correctly at least, since Katherine was able to get reasonable readings. LEDs deserve their own section later. Finally, we need to make sure not to run out of the SMD components like capacitors and resistors (took a bunch just in case), because apparently they’re not kept stocked and we’d have to order them, which causes delays. We could cut apart the PCB into each panel using scissors since it was thin and came with perforated marks.

Highlights of hand soldering include using tape to line up the headers relatively straight so the beetle will be able to fit properly. The single headers don’t have to be that straight because we were planning on wiring those connections.

I could now get started on trying to get the LEDs to work. At first, I tried to use the FastLED library since that’s what a bunch of example Neopixel projects on Adafruit’s website used. Unfortunately it led to a bunch of internal errors within the library itself, and everytime I fixed one, a new error would pop up. It was like playing whack-a-mole, except hitting things with a hammer would probably not solve the problem.

Next I tried the Adafruit Neopixel library since that was mentioned on the Neopixel page. That compiled fine, but then nothing happened. We tried checking the pins, debugging with print statements (nothing printed, not even in the setup() before any real code was run). Admittedly, our setup may not have been the most stable since we didn’t solder the battery/boost converter stuff yet (couldn’t find any solid core wires, which would’ve been more helpful), but I don’t think that should be the issue. In addition, we are relatively sure all of them are oriented correctly after consulting a pin out of the component online.

In other news, an ongoing conundrum has been how accurate our phones are for measuring dB. Previous data showed that each phone was relatively precise (Katherine consistently got the lowest readings and Lucy the highest), but I volunteered as tribute to formalize our findings with fun things such as box plots and outlier analysis and standard deviation!

For our recording session with the music students, we tried different variables to see how sensitive the mics are and how much specific placement really matters. Specifically, we tried trials where we lined up the phones in different orders, and for the last trial, we placed the phones as far away as possible (other side of the room).

Conclusions:

  • no outliers, even with the very far away trial; it does skew the data ofc, and the box plots look more symmetrical without it
    • mostly avg and max was affected by this ^
    • std dev calculations not really affected, since everyone should be affected in about the same way
    • katherine’s avg didn’t change without the last trial because the last trial didn’t have the lowest value XD
  • Lucy’s phone seemed most sensitive (largest drop) to being farther away
  • Everyone’s std dev were within 2 db if ignoring the last trial

I didn’t expect the light debugging to be so difficult, especially since there’s a bunch of straightforward example code to try. That was supposed to be done by the end of this week, but I’ll try to have it done by Friday’s recording session instead, and perhaps we should meet with prof to ask for help.

Team Status Report for 3/16

General updates

Due to significant differences in different sound apps reading the same sound, we decided to narrow down the variables involved by all downloading the same app and placing votes as close together as possible. We still get different dBs for the same app, but we also have different phones/mics, which we can’t control. The standard deviation between us is about 3 to 4 dB, which is outside of our desired range of being within 2dB of accuracy. The problem is, we don’t even know who is the most accurate, only that we are precise. Luckily, Prof Sullivan offered to give us a more trustworthy decibel meter starting the week after next, which can hopefully clear up this debate permanently. We will be taking it to practice sessions with the music students that we have been coordinating times with.

We also discussed microphone signal processing in our weekly meeting with Prof Fedder. Since microphone noise is negligible compared to the loudness we’re measuring, and we’re only interested in measuring loudness, filtering out noise probably isn’t necessary. A basic version of mic signal processing would measure the amplitude of the incoming signal a certain number of times per second and linearly scale that to dB levels. A more sophisticated version would use an FFT (https://projecthub.arduino.cc/abhilashpatel121/easyfft-fast-fourier-transform-fft-for-arduino-03724d) to see the “spikes” within the frequency range we are interested in, and take the maximum of the spike amplitudes. The problem with either version is that in order to account for frequency overtones and Nyquist’s theorem, we need to sample thousands of times per second. This might be computationally expensive.

What are the most significant risks that could jeopardize the success of the project? How are these risks being managed? What contingency plans are ready?

The PCB doesn’t get here on time (expected arrival Tuesday). Given how much this delay has blocked our progress this first iteration, when we order the final (flex) PCB, we plan to pay extra for fast shipping instead of regular shipping, since we have enough left in our budget.

Were any changes made to the existing design of the system (requirements, block diagram, system spec, etc)? Why was this change necessary, what costs does the change incur, and how will these costs be mitigated going forward?

No changes were made to the existing design. We’re still planning to order a flex PCB with the final design once we have tested the rigid prototype PCB and noted what changes need to be made.

Provide an updated schedule if changes have occurred.

The schedule has been updated. PCB creation/delivery took longer than expected, and a lot of tasks depend on us having the PCB, since a lot of the components are tiny SMD things that we can’t try to do by hand.

This is also the place to put some photos of your progress or to brag about a component you got working.

Here is a picture of the stencil for our PCB.

A tilted view of the PCB stencil in light blue.

Gantt Chart changes:

Software: Due to difficulties in getting the Bluetooth connection to work on the mobile app, we have allocated an extra half a week to figuring it out. Additionally, the decibel reading display and visualization algorithms have been moved forward so that they can be done by the interim demo (4/1). Since full integration of the bracelet and the web app won’t occur until after the interim demo, these pages will be displaying information using dummy data.

Hardware: Electronic prototyping/PCB assembly and microphone signal processing have been moved forward by a half-week as well, because we can’t do much without the PCB being physically here.

Katherine’s Status Report for 3/16

To correct an error from last week: this week, I was supposed to be working on microphone signal processing, not LED signal setup, in addition to electronic prototyping.

In our weekly check-in discussion, I got an idea of how microphone signal processing is going to work in the context of our project. My eventual plan to determine the necessary sampling frequency is to test the bracelet microphones by sampling at the higher rate (including all expected overtones) when at a music practice. I hypothesize that the overtone frequencies will tend to be softer/have smaller amplitudes, which will reduce the frequency range we would have to work with and therefore our required sampling speed as well.

Some of my progress is on schedule, while other parts are behind.

The on-schedule elements are as follows. I wrote the logic for the ratio of microphone decibel values affecting the color of each LED when in directionality mode. When in directionality mode, the LEDs light according to a dB value that is a weighted average of the dB value for either direction (the weights differ depending on the LED’s location relative to either microphone). The farthest and second-closest LEDs from the Beetle on each side will display the color value corresponding to their side’s microphone input, while the LEDs closest to the Beetle will display a color value corresponding to ⅔ of their side’s microphone value added to ⅓ of the other side’s microphone value. When not in directionality mode, all LEDs will display a color corresponding to the average of the two microphone input amplitudes. The logic for determining direction already exists (I believe last week’s “how determining direction… will work” was in the context of LED colors?). For the record, it takes the ratio of the amplitude from each microphone input and assumes that a sound equidistant from each mic will have a 1:1 L:R ratio, while a sound completely from the left or right will have a ratio of X:1 or 1:X (X being the maximum ratio). It then scales based on the ratio of input amplitudes to find an angle value between these. X will be iterated on during directionality testing.

I am behind on establishing the Beetle-Bluetooth connection. According to https://github.com/espressif/esp-idf/issues/6550, in order to establish a connection to my phone with the correct security, I need to turn on secure simple pairing or change the mode to mixed mode; I need to research if it is recommended to change these features of the Beetle’s Bluetooth module. Further research suggests that it would be useful to connect to the Beetle through a third-party app (https://wiki.dfrobot.com/DFRobot_Bluetooth_4.1__BLE__User_Guide#target_2 states that it is required for Bluetooth 4.1, and our Beetle uses Bluetooth 5), but none of the apps I tried could recognize the Beetle.

Tasks that depend on having the PCB are also behind. The PCB is scheduled to arrive on Tuesday. Once the PCB is assembled, I plan to continue work on electronic prototyping (including researching the Beetle-Bluetooth issue) and microphone signal processing. I will also help with testing the webapp if necessary and with visualizing decibel readings if time permits.