ntoll
commented
8 years ago Initial thoughts on DSL.
From a music teacher's perspective, the simplest thing we can do is create a Python list containing items that specify the following pieces of information:
- A meaningfully named pitch - basically a note name and octave.
- A means of specifying duration. In "regular" music we use fractions for this. (A semi-breve is a "whole" note - i.e. 1, a minim is a 1/2 note, a crotchet a 1/4 note etc...)
To provide an example of how this may look: 'A1:16' could represent the note 'A' in octave 1 that lasts for 16 ticks (where a tick is some arbitrary length of time defined by a tempo setting in BPM - see below).
Furthermore, we could short-cut octave and duration so the following list contains four notes all in octave 1 with a duration of 4 ticks: ['C1:4', 'D', 'E', 'F', ]
In other words, the octave and duration are states that carry over to the subsequent notes until they are re-specified, perhaps like this: ['C1:4', 'D:2', 'D', 'E:8']
Finally, the note names should be case insensitive so 'c' and 'C' are equivalent.
Setting the tempo could be set by a function perhaps looking like this:
def set_tempo(ticks, bpm):
"""
Sets the approximate tempo for playback.
A number of ticks (integer) are to be played at a certain frequency per minute
(expressed as the more familiar BPM - beats per minute).
""""
...Ergo, set_tempo(4, 120) ( a suggested default) would feel like setting a crotchet (that lasts 4 ticks) at 120 bpm (a brisk march tempo). As a result, 16 ticks = semibreve, 8=minim, 2=quaver and 1 a semiquaver allowing us the maximum rhythmic definition to be expressed in terms of semiquavers.
We could also have a get_tempo() function that returns a tuple of (ticks, bpm).
The simplest functionality we'd need to provide to play things could be expressed as four functions:
play(pin, note)- takes a pin and a string expressing pitch and duration, e.g.:'C1:8'and plays it at the pre-defined tempo .pitch(pin, freq, millis)- takes an integer representation of a frequency of a pitch (e.g. 440 - concert A) and a duration in milliseconds. This would allow us to create interesting sweeping effects and non-diatonic notes (i.e. not part of the scale system) for arbitrary periods of time. It'd be a great way to make a siren for example.tune(pin, notes, wait=True, loop=False)- takes a pin and a list of string based note definitions (a la description above). The optionalloopandwaitkeywords would work just like theanimatefunction in thedisplaymodule.stop(pin)- stops any generation of sound on the given pin.
All of the above could live under the microbit.music namespace.
Thoughts..? Could this be implemented in the C++ layer..? As @whaleygeek said on the mailing list - this could be a total game-changer for MicroPython on the micro:bit... everyone would want to use Python simply because you can make things go "bloop" with little effort. ;-)
matthewelse
dpgeorge
It should be possible to make sweet music using MicroPython on the micro:bit.
To this end there should be a
musicnamespace containing the simplest yet most helpful functions needed to make this work.Furthermore, we'll need to define an easy-to-understand DSL for kids and teachers to use for specifying notes.
Finally, it would be wonderful if such interactions could be optionally allowed to run in the background (in a similar way to the
display.animatemethod).