The sound that's being recorded is noisy because the microphone is the cheapest on amazon 😅 Have a way to improve the recorded quality.

https://realpython.com/python-concurrency/
https://realpython.com/async-io-python/

Explore the following ideas:

• First try to get it to work using VScode DEV Containers.
• To use Neovim exrc and per-project lua files to specify the language server container to hook into.
• Ideal world would be to have something like VSCode Containers.
• See if perhaps installing the development tools (Neovim, config files, etc) in the container might be better or not. Since container CPU and memory might be thinner the UX can drop perhaps?

Check it works on Raspberry Pi:

• Service starts on restarts.
• You can write an entry with Python.
• You can read an entry with JavaScript (little NodeJS app).

We must stop the detectors when the sound is being played back to prevent audio feedback.

Provide and document a deployment model for the app.

TODO:

• Figure out how to run individual tasks from the playbook using the CLI. Maybe using tags?
• In the host the project files have eulersson:eulersson permissions. See with the posix.synchronize module how they can end up on the target host with anesowa:anesowa permissions. Maybe skipping the archive flag?
• Use the template module to parametrize the service name.
• See if PulseAudio stuff can be automated!
• Upon copying over restart the services (Ansible handler), the service should build the container and run it!
• Document. Also change the Development workflow section since now instead of rsync or volume binding the ansible playbook could be used.
• Set default volumes to 100%
• host vars have an array to iterate over all entries and set

It can be useful to know how many players do we have connected.

See where is the most convenient way to store it, I would say into a file somewhere? Or what other kind of registry is worth using for storing persistent state otherwise? For now use a file.

Make sure I have not broken anything while adapting the Dockerfiles for docker compose and local development...

The ansible deployment also configures what recording source is going to be used. This is usually written down in vars. But it would make it more user friendly to present it as an interactive prompt. Specially because this step is critical!

Here's an example on how this can be done:

- name: Get list of numbers from foo
  command: foo
  register: foo_output
  changed_when: false
  check_mode: no

- name: Extract numbers from foo output
  set_fact:
    numbers_list: "{{ foo_output.stdout_lines }}"

- name: Display options to user and save preference
  block:
    - name: Prompt user to choose a number
      pause:
        prompt: "Please choose a number from the list: {{ numbers_list }}"
        echo: yes
      register: user_choice

    - name: Save preference for chosen number
      command: bar "{{ user_choice.user_input }}"
      changed_when: false
      check_mode: no
  when: numbers_list | length > 0

This is to be done with the actual system that gives you scores and not with a transference learnt neural network.

You have a top_class_name and a list of predictions.

From that build a list with the class names and do not include there the ones to be ignored.

Grab the first occurrence and use it as a suffix.

https://www.tensorflow.org/tutorials/audio/simple_audio
https://www.tensorflow.org/lite/guide/build_arm
https://www.tensorflow.org/lite/models/convert/
https://www.tensorflow.org/lite/examples/audio_classification/overview
https://www.youtube.com/playlist?list=PLQY2H8rRoyvz_anznBg6y3VhuSMcpN9oe
https://www.tensorflow.org/tutorials/audio/transfer_learning_audio
https://www.tensorflow.org/tutorials/audio/transfer_learning_audio
https://www.tensorflow.org/tutorials/audio/transfer_learning_audio https://www.tensorflow.org/hub/tutorials/yamnet <-- THIS

• Transfer learning with YAMNet for environmental sound classification
• Build your own real-time voice command recognition model with TensorFlow
• Simple Audio Recognition on a Raspberry Pi using Machine Learning (I2S, TensorFlow Lite)

• Read guide
• Produce the 2-3 needed programs in Python.
• https://stackoverflow.com/questions/71445060/how-to-play-sound-in-c-from-scratch-linux
• on rpi 3 compilation fails of cppzmq so use zeromq/cppzmq#430

When a sound is detected and bounced back to the annoying neighbour we need to be clear that the neighbours knows this sound is produced from her, that's why adding a preroll sound can make it easier: "Your sounds are disturbing!!! ".

For that it will be the playback distributor the one in charge to pick one preroll sound and hand it to all connected sound players. It should be picked randomly based on the current time.

Then the player module needs to first play the selected preroll and then the sound.

Prepare the C projects to have unit tests.

• Explore automatic discovery of .local domains and identify slaves and masters by the domain names.
• See inter-container communication, what kind of networking is needed?

Lay down the infrastructure to test python code using Robot Framework.

It might be worth only if you share the home LAN with people you don't trust, otherwise the influx DB service for instance could be reached and compromised.

Explore if we can use the docker logs, how long they stay for, if we can use a logging driver.

As a learning exercise Grafana would be a suitable choice?

For an IoT project this might be clugging the small powers of the Raspberry Pis...

We could parametrize Grafana installation in the ansible playbook so at least I still learn it and don't discard it for the simple fact of "it would consume too much power".