Here’s a weird little function I just wrote to “slice” an integer out of a byte:

int byteSlice(byte input, byte startIndex, byte endIndex){

  // generates an integer value from an arbitrary slice of a byte
  // Example:
  //
  // index:   01234567
  // input = B01101100 (int 108)
  //
  // startIndex = 1
  // endIndex = 4
  // slice = B1101
  // returns int 13

  byte output;

  // shift left to shave off bits before startIndex
  output = input << startIndex;
  // shift right to shave off bits after endIndex
  output = output >> (7-endIndex) + startIndex;

  return int(output);
}

This basically takes out a chunk of a byte and gives you the integer representation of its bits.  The input index byte datatypes are a neurotic memory optimization, since the indices can’t be greater than 7. Example Arduino implementation:

void setup(){

  Serial.begin(9600);
  byte in = 108;

  Serial.print(in, DEC);
  Serial.print("\t");
  Serial.println(in, BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 0, 7), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 0, 7), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 1, 4), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 1, 4), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 3, 6), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 3, 6), BIN);
}

void loop(){
}

Here are two super-useful Arduino utility functions I just devised for my thesis:

byte arrayToByte(int arr[], int len){
  // Convert -1 to 0 and pack the array into a byte
  int i;
  byte result = 0;

  for(i=len-1; i>=0; i--){
    if(arr[i] == -1){
      result &= ~(0 << i);
    } else {
      result |= (1 << i);
    }
  }
  return result;
}

int* byteToArray(byte in){
  int i, temp, out[8];

  for(i=0; i<8; i++){     temp = (in >> i) & 1;
    if(temp == 0) temp = -1;
    out[i] = temp;
  }
  return out;
}

The first function takes in an array of up to 8 integers valued 1 or -1 and generates a corresponding byte; the second does the reverse.  Easy to modify for other integer values.

A perceptron is one of the simplest forms of neural networks: a linear classifier.  It is a method of associating input patterns with output patterns, with the advantage that it is forgiving of noise in the input.

The network consists of an input and output layer (and optional “hidden” layers in between) with weighted connections between all of them.  To train a perceptron, you present an input pattern and the output pattern it should learn to output.  Then you step through each pair of neurons in each pair of layers and modify their weights with this equation:

∆w_i = c (d – sign( ∑x_iw_i)) x_i

…where w_i is the ith weight (real-valued), c is the learning constant (i.e. 0.1), d is the desired output for this node (1 or -1), and x_i is the input activation (1 or -1).  The input activation term indicates that the input node in question “contributes” to the output or “inhibits” it.  sign() is given by:

sign(x) = 1 if x ≥ 0, else -1

Here’s a C++ implementation from my Neuroduino Arduino library:

int Neuroduino::signThreshold(double sum){
	if (sum >= _net.Theta) {
		return 1;
	} else {
		return -1;
	}
}

double Neuroduino::weightedSum(int l, int node){
	// calculates input activation for a particular neuron
	int i;
	double currentWeight, sum = 0.0;

	for (i=0; i<_net.Layer[l-1]->Units; i++) {
		currentWeight = _net.Layer[l]->Weight[node][i];
		sum += currentWeight * _net.Layer[l-1]->Output[i];
	}

	return sum;
}

void Neuroduino::adjustWeights(int trainArray[]){
	int l,i,j;
	int in,out, error;
	int activation;	// for each "rightmost" node
	double delta;

	for (l=1; l<_numLayers; l++) {
		// cycle through each pair of nodes
		for (i=0; i<_net.Layer[l]->Units; i++) {
			// "rightmost" layer
			// calculate current activation of this output node
			activation = signThreshold(weightedSum(l,i));
			out = trainArray[i];	// correct activation
			error = out - activation;	// -2, 2, or 0

			for (j=0; j<_net.Layer[l-1]->Units; j++) {
				// "leftmost" layer

				in = _net.Layer[l-1]->Output[j];

				delta = _net.Eta * in * error;
				_net.Layer[l]->Weight[i][j] += delta;
			}
		}
	}
}

void Neuroduino::simulateNetwork(){
	/*****
	 Calculate activations of each output node
	 *****/
	int l,j;

	for (l=_numLayers-1; l>0; l--) {
		// step backwards through layers
		// TODO: this will only work for _numLayers = 2!
		for (j=0; j < _net.Layer[l]->Units; j++) {
			_output[j] = signThreshold(weightedSum(1, j));
		}
	}
}

In my thesis I wanted to read the signal strength of incoming packets and store it in a variable on a microcontroller without using the XBee’s API Mode (In API Mode, you construct packets to command the XBees explicitly, as opposed to just sending serial data in AT or “Transparent Mode”).  XBee modules have an RSSI (Received Signal Strength Indicator) pin that outputs a PWM signal representing this value.  But how do you turn that PWM duty cycle into a useable integer on your microcontroller?  Luckily Arduino has a function made for just this application: pulseIn.

1. Connect the RSSI pin (pin 6) to a digital pin on your microcontroller.
2. Use this line of code in your Arduino loop:

   rssiDur = pulseIn(digitalPin, LOW, 200);

pulseIn returns the duration of a pulse (specified HIGH or LOW) in microseconds (µs).  The 200 is a timeout value in µs—it waits this long to see if there’s going to be a pulse.  Since the XBee’s RSSI PWM period is 200µs, we want to wait at most that long to see if there’s a pulse at all.

Since this function gives you a duration, it’s up to you to map that to a value relevant to your program.  Since the maximum duration of the pulse would be 200µs, you could map that to your logical maximum.

Keep in mind that if you were planning on using API Mode anyway, every API Mode packet has the latest RSSI within it.

In the 5th grade, I devised my own language; for I could think of no better or more fascinating challenge. For my Master’s thesis at the Interactive Telecommunications Program at NYU, I could think of no better or more fascinating challenge than to invent language-inventing machines. What resulted was The Dawn Chorus, a group of electronic sculptures that do just this—emergently, and autonomously. Using a suite of custom hardware and a simple neural network for each device, the individuals learn from each other and are thus able to converge on common, conventional “words” for their experiences, such as a flash of light or sudden noise.

Seem them in action:

My final thesis presentation:

All the technical details are in the thesis paper!

This Dawn Chorus has gradually and emergently developed its own song-language, a metastructure that was never designed into any of the Chorus’s individual members.  Each member of the Chorus has the ability to sense the light and sound of its environment and the ability to vocalize—as well as the ability to learn from the actions of its neighbors.  In this way, the Chorus is able to naturally develop its own set of linguistic, musical conventions, entirely independently.

These sculptures contain a compact set of electronics comprising a microcontroller, sound and light sensors, a hybrid digital-analog synthesizer of my own design, a radio module and a speaker.  Each unit uses a simple neural network learning algorithm to associate environmental events and the actions of its milieu with generative sound patterns.  In short, the entities that make up the Dawn Chorus learn to talk to each other.

But what about?  The Dawn Chorus is not meant as an attempt to mimic animal behavior, but rather as an experiment in emergent poetics.  I see the songs of the Chorus as more musical than communicative, as more of a series of conversational poems than a survival strategy.  In time, we humans may even learn their language—but they will continue to enjoy it on their own.

Sketches of possible sculptural forms (these are roughly 8-10″ in height).  The first four are my favorites:

Sound prototyping: A short composition of 4-7 sine wave oscillators harmonizing and disharmonizing:

Two videos of synth design approaches: 8-bit R2R DAC and Schmidt trigger oscillator.