Assemblr

After a lot of (friendly) arguing, we finally completed our semester finals project.

Demonstration video

Presentation

Figma prototype

Due to practical concerns, we decided early on a mostly digital product, which would act as a visual and auditory aid for the action happening in the classroom. We tested on our classmates, families and most importantly; schoolkids.

Our early process was informed by interviews with both employees at the Technical Museum and students in secondary school and above.

noteSend:

https://makecode.microbit.org/_9i2TfHTsKJ40

noteReciever:

MIDI:

#include <MIDIUSB.h>

#include <MIDIUSB_Defs.h>

#include <frequencyToNote.h>

#include <pitchToFrequency.h>

#include <pitchToNote.h>

//#include <Tone.h>

/*

 * MIDIUSB_test.ino

 *

 * Created: 4/6/2015 10:47:08 AM

 * Author: gurbrinder grewal

 * Modified by Arduino LLC (2015)

 */

#include "MIDIUSB.h"

/*

 * This code includes the MIDIUSB library, which is used for sending and receiving MIDI messages via USB.

 */

// First parameter is the event type (0x09 = note on, 0x08 = note off).

// Second parameter is note-on/note-off, combined with the channel.

// Channel can be anything between 0-15. Typically reported to the user as 1-16.

// Third parameter is the note number (48 = middle C).

// Fourth parameter is the velocity (64 = normal, 127 = fastest).

void noteOn(byte channel, byte pitch, byte velocity) {

  midiEventPacket_t noteOn = {0x09, 0x90 | channel, pitch, velocity};

  MidiUSB.sendMIDI(noteOn);

  Serial.print(" plays note ");

  Serial.println(pitch);

}

/*

 * This function sends a "note on" MIDI message with the specified channel, pitch, and velocity. The MIDI message is created as a midiEventPacket_t structure and then sent using the MidiUSB.sendMIDI function.

 */

void noteOff(byte channel, byte pitch, byte velocity) {

  midiEventPacket_t noteOff = {0x08, 0x80 | channel, pitch, velocity};

  MidiUSB.sendMIDI(noteOff);

}

/*

 * This function sends a "note off" MIDI message with the specified channel, pitch, and velocity. The MIDI message is created as a midiEventPacket_t structure and then sent using the MidiUSB.sendMIDI function.

 */

float frequencies[127];

int a = 440; // a is 440 hz...

float midiToFreq(int midiNote) {

    return (a * pow(2.0, (midiNote - 69) / 12.0));

}

/*

 * This code initializes an array of float values called frequencies with 127 elements, and also defines a constant a with a value of 880. The midiToFreq function takes a MIDI note number as an argument and returns the corresponding frequency in Hz using the formula A4 * 2^((midiNote - 69) / 12).

 I then multiply the result by 20 to compensate for the motor

 */

void setup() {

  Serial1.begin(9600);

  delay(5000);

  for (int i = 0; i < 127; i++){

   frequencies[i] = midiToFreq(i);

   //Serial.println(frequencies[i]);

  }

  pinMode(3,OUTPUT);

  digitalWrite(3,HIGH);

}

/*

 * This function is called once when the program starts up. It initializes the serial communication at a baud rate of 115200 and waits for 5 seconds using delay(5000). It then loops through all 127 possible MIDI note numbers and calculates their corresponding frequencies using the midiToFreq function, storing the results in the frequencies array and printing them to the serial monitor.

 */

// First parameter is the event type (0x0B = control change).

// Second parameter is the event type, combined with the channel.

// Third parameter is the control number number (0-119).

// Fourth parameter is the control value (0-127).

void controlChange(byte channel, byte control, byte value) {

  midiEventPacket_t event = {0x0B, 0xB0 | channel, control, value};

  MidiUSB.sendMIDI(event);

}

/*

 * This function sends a "control change" MIDI message with the specified channel, control number, and value. The MIDI message is created as a midiEventPacket_t structure and then sent using the MidiUSB.sendMIDI function.

 */

int voiceCount = 0;

/*

 * The first line of the loop() function declares a variable called rx of type midiEventPacket_t. This variable is used to store MIDI events as they are read from the USB MIDI input.

 The loop then enters a do-while loop, which continues to execute as long as the rx.header value is not equal to 0. This loop is used to continually read MIDI events and process them as they are received.

 Inside the if statement, the code checks if the rx.header value is not equal to 0, indicating that a MIDI event has been received. If a MIDI event has been received, the code processes the event as follows:

 */

void loop() {

  midiEventPacket_t rx;

  do {

    if (

    rx = MidiUSB.read();

    rx.header != 0) {

      //Serial.print(rx.byte2);

      //Serial.print(" note = ");

      float myNote = frequencies[rx.byte2];

      //Serial.write("$");

      //Serial.println(myNote);

      //Serial.print("STATUS = ");

      //Serial.println(rx.byte1);

        /* * This function sends a "control change" MIDI message with the specified channel, control number, and value. The MIDI message is created as a midiEventPacket_t structure and then sent using the MidiUSB.sendMIDI function. */        

      if(rx.byte1 == 144){

        Serial1.println(rx.byte2);

        voiceCount ++;

        digitalWrite(3,LOW);

        playNote(frequencies[rx.byte2]);

        } else if(rx.byte1 = 128){

        voiceCount--;

        Serial1.println(rx.byte2+127);

        if(voiceCount == 0){

          noTone(2);

          digitalWrite(3,HIGH);

        }

      }

    }

  } while (rx.header != 0);

}

/*

 * If the MIDI event is a "note on" event, the code increments a counter called voiceCount, which is used to keep track of how many notes are currently being played. The code then calls a function called playNote() to play the note. The playNote() function takes a frequency as an argument and plays that frequency on pin 2 using the tone() function.

 If the MIDI event is a "note off" event, the code decrements the voiceCount counter. If voiceCount is zero, this means that there are no notes currently being played, so the code turns off the sound using the noTone() function.

 */

void playNote(int note){

  int voice = findVoice(note);

  noteOn(0, note, 127); // send MIDI note on message with voice index

  tone(2,note);

}

// Voice allocation code:

int voices[4] = {-1, -1, -1, -1};

 int findVoice(int midiNote){

  bool foundVoice = false;

  for(int i = 0; i<4; i++){

    if(voices[i] == -1){

      voices[i] = midiNote;

      foundVoice = true;

      return i;

    }

  }

  if(!foundVoice){

    int randomlySelectedVoice = random(0,3);

    voices[randomlySelectedVoice] = midiNote;

    return randomlySelectedVoice;

  }

}

int releaseVoice(int midiNote){

  for(int i = 0; i<4; i++){

    if(voices[i] == midiNote){

      voices[i] = -1;

      return i;

    }

  }

HytteBytte siste versjon nå tilgjengelig! med presentasjonsside inkludert.