Set your calculator to “maths”…

Yesterday two basic criteria for our New Year’s LED project were established:

1. Our “ball” will actually be an icosahedron — a 20-sided shape — for ease of assembly. Each face will have six LEDs, for 120 LEDs total.
2. To create meaningful patterns on the ball, rather than just random blinking, it’s necessary to know the coordinates of every LED. Therefore, a software model will need to approximate the physical thing.

The first step to finding the LED coordinates is to establish the positions of each of the 12 vertices of the icosahedron, even though there are no LEDs there. Once those points are known, all the LEDs can be located through interpolation.

There are a number of ways of constructing an icosahedron…the Greeks were working up the math in 400 B.C., the Scots might have hammered it out in the late Neolithic Age…though some protozoa and viruses had us all beat by half a billion years or so.

Our “ball” will hang from one vertex at the top, so we’ll follow a construction method to suit. When viewed down the vertical axis, there’s a clear 5-fold symmetry:

Starting with just the radius of those “spokes” from the center (we’ll use a value of 1.0 — the units are arbitrary), a couple formulas are all that’s needed to find the 3D position of one vertex, and from that to replicate all the remaining vertices by revolving around the center axis. Wikipedia can help with the maths!

From those vertices we can then identify edges and faces. Using two edge vectors from each face, the triangular 1-2-3 layout of the LEDs can be interpolated across this. Wrapped up in just a short Processing sketch, we now have a tumbling 3D icosahedron with LED dots in the desired places! Later, we’ll issue colors based on each LED’s location.

A test sketch for Processing is available from the project’s Github repository. This does not yet communicate with an Arduino or the LEDs; it is strictly for validating the geometry. It’s a good visual match for the model on the table!

Lauren Ipsum: Computer Science for Kids.

Lauren Ipsum is a children’s story about computer science. In 20 chapters and ~35K words, she encounters dozens of ideas from timing attacks to algorithm design, the subtle power of names, and how to get a fair flip out of even the most unfair coin.

The book is mostly written, and Ytaelena is working on the illustrations and layout. We’ve been working on this project over nights & weekends for about a year and a half. In return for a signed pre-sale copy of the book, your pledges will go towards translating the book into Spanish, Portuguese, and other languages.

Read more…

160 pages, dozens of illustrations. Perfect for kids. Available in paperback, Kindle and iPad in December 2011.

Javascript PC Emulator – Linux in a browser…

This PC emulator is written in Javascript. The emulated hardware consists in:
• a 32 bit x86 compatible CPU
• a 8259 Programmble Interrupt Controller
• a 8254 Programmble Interrupt Timer
• a 16450 UART.

The code is written in pure Javascript using Typed Arrays which are available in recent browsers. It was tested with Firefox 4 and Google Chrome 11 on Linux, Window and Mac (it does not work with Chrome 12 beta. As far as I know, it is a bug in the browser). In any case, a fast Javascript engine is needed to have good performance.

Tech notes here.

“Invent Your Own Computer Games with Python” is a free book that teaches you how to program in the Python programming language. Each chapter gives you the complete source code for a new game, and then teaches the programming concepts from the example.

“Invent with Python” was written to be understandable by kids as young as 10 to 12 years old, although it is great for anyone of any age who has never programmed before.

This second edition has revised and expanded content, including using the Pygame library to make games with graphics, animation, and sound.

You can buy it or read/download it online CC version.

If you have a lot of button inputs for a project, keeping track of them (whether they’re pressed, just pressed or just released) and debouncing can get a bit hairy. here is some sample code that will keep track of as many buttons as you’d like. The example shows 6. To change the pins or number of buttons, just put them in the array called “buttons” and the rest of the code will automatically adjust. (The code is in Arduino-ese but its pretty much just straight up C)
Enjoy!

#define DEBOUNCE 10  // button debouncer, how many ms to debounce, 5+ ms is usually plenty

// here is where we define the buttons that we'll use. button "1" is the first, button "6" is the 6th, etc
byte buttons[] = {14, 15, 16, 17, 18, 19}; // the analog 0-5 pins are also known as 14-19
// This handy macro lets us determine how big the array up above is, by checking the size
#define NUMBUTTONS sizeof(buttons)
// we will track if a button is just pressed, just released, or 'currently pressed' 
byte pressed[NUMBUTTONS], justpressed[NUMBUTTONS], justreleased[NUMBUTTONS];

void setup() {
  byte i;

  // set up serial port
  Serial.begin(9600);
  Serial.print("Button checker with ");
  Serial.print(NUMBUTTONS, DEC);
  Serial.println(" buttons");

  // pin13 LED
  pinMode(13, OUTPUT);

  // Make input & enable pull-up resistors on switch pins
  for (i=0; i< NUMBUTTONS; i++) {
    pinMode(buttons[i], INPUT);
    digitalWrite(buttons[i], HIGH);
  }
}

void check_switches()
{
  static byte previousstate[NUMBUTTONS];
  static byte currentstate[NUMBUTTONS];
  static long lasttime;
  byte index;

  if (millis() < lasttime) {
     // we wrapped around, lets just try again
     lasttime = millis();
  }

  if ((lasttime + DEBOUNCE) > millis()) {
    // not enough time has passed to debounce
    return;
  }
  // ok we have waited DEBOUNCE milliseconds, lets reset the timer
  lasttime = millis();

  for (index = 0; index < NUMBUTTONS; index++) {
    justpressed[index] = 0;       // when we start, we clear out the "just" indicators
    justreleased[index] = 0;

    currentstate[index] = digitalRead(buttons[index]);   // read the button

    /*     
    Serial.print(index, DEC);
    Serial.print(": cstate=");
    Serial.print(currentstate[index], DEC);
    Serial.print(", pstate=");
    Serial.print(previousstate[index], DEC);
    Serial.print(", press=");
    */

    if (currentstate[index] == previousstate[index]) {
      if ((pressed[index] == LOW) && (currentstate[index] == LOW)) {
          // just pressed
          justpressed[index] = 1;
      }
      else if ((pressed[index] == HIGH) && (currentstate[index] == HIGH)) {
          // just released
          justreleased[index] = 1;
      }
      pressed[index] = !currentstate[index];  // remember, digital HIGH means NOT pressed
    }
    //Serial.println(pressed[index], DEC);
    previousstate[index] = currentstate[index];   // keep a running tally of the buttons
  }
}

void loop() {
  check_switches();      // when we check the switches we'll get the current state

  for (byte i = 0; i < NUMBUTTONS; i++) {
    if (justpressed[i]) {
      Serial.print(i, DEC);
      Serial.println(" Just pressed");
      // remember, check_switches() will CLEAR the 'just pressed' flag
    }
    if (justreleased[i]) {
      Serial.print(i, DEC);
      Serial.println(" Just released");
      // remember, check_switches() will CLEAR the 'just pressed' flag
    }
    if (pressed[i]) {
      Serial.print(i, DEC);
      Serial.println(" pressed");
      // is the button pressed down at this moment
    }
  }
}

if you want, you can even run the button checker in the background, which can make for a very easy interface. Remember that you’ll need to clear “just pressed”, etc. after checking or it will be “stuck” on

#define DEBOUNCE 10  // button debouncer, how many ms to debounce, 5+ ms is usually plenty

// here is where we define the buttons that we'll use. button "1" is the first, button "6" is the 6th, etc
byte buttons[] = {14, 15, 16, 17, 18, 19}; // the analog 0-5 pins are also known as 14-19
// This handy macro lets us determine how big the array up above is, by checking the size
#define NUMBUTTONS sizeof(buttons)
// we will track if a button is just pressed, just released, or 'currently pressed' 
volatile byte pressed[NUMBUTTONS], justpressed[NUMBUTTONS], justreleased[NUMBUTTONS];

void setup() {
  byte i;

  // set up serial port
  Serial.begin(9600);
  Serial.print("Button checker with ");
  Serial.print(NUMBUTTONS, DEC);
  Serial.println(" buttons");

  // pin13 LED
  pinMode(13, OUTPUT);

  // Make input & enable pull-up resistors on switch pins
  for (i=0; i< NUMBUTTONS; i++) {
    pinMode(buttons[i], INPUT);
    digitalWrite(buttons[i], HIGH);
  }

  // Run timer2 interrupt every 15 ms 
  TCCR2A = 0;
  TCCR2B = 1<<CS22 | 1<<CS21 | 1<<CS20;

  //Timer2 Overflow Interrupt Enable
  TIMSK2 |= 1<<TOIE2;

}

SIGNAL(TIMER2_OVF_vect) {
  check_switches();
}

void check_switches()
{
  static byte previousstate[NUMBUTTONS];
  static byte currentstate[NUMBUTTONS];
  static long lasttime;
  byte index;

  if (millis() < lasttime) {
     // we wrapped around, lets just try again
     lasttime = millis();
  }

  if ((lasttime + DEBOUNCE) > millis()) {
    // not enough time has passed to debounce
    return;
  }
  // ok we have waited DEBOUNCE milliseconds, lets reset the timer
  lasttime = millis();

  for (index = 0; index < NUMBUTTONS; index++) {

    currentstate[index] = digitalRead(buttons[index]);   // read the button

    /*     
    Serial.print(index, DEC);
    Serial.print(": cstate=");
    Serial.print(currentstate[index], DEC);
    Serial.print(", pstate=");
    Serial.print(previousstate[index], DEC);
    Serial.print(", press=");
    */

    if (currentstate[index] == previousstate[index]) {
      if ((pressed[index] == LOW) && (currentstate[index] == LOW)) {
          // just pressed
          justpressed[index] = 1;
      }
      else if ((pressed[index] == HIGH) && (currentstate[index] == HIGH)) {
          // just released
          justreleased[index] = 1;
      }
      pressed[index] = !currentstate[index];  // remember, digital HIGH means NOT pressed
    }
    //Serial.println(pressed[index], DEC);
    previousstate[index] = currentstate[index];   // keep a running tally of the buttons
  }
}

void loop() {
  for (byte i = 0; i < NUMBUTTONS; i++) {
    if (justpressed[i]) {
      justpressed[i] = 0;
      Serial.print(i, DEC);
      Serial.println(" Just pressed");
      // remember, check_switches() will CLEAR the 'just pressed' flag
    }
    if (justreleased[i]) {
      justreleased[i] = 0;
      Serial.print(i, DEC);
      Serial.println(" Just released");
      // remember, check_switches() will CLEAR the 'just pressed' flag
    }
    if (pressed[i]) {
      Serial.print(i, DEC);
      Serial.println(" pressed");
      // is the button pressed down at this moment
    }
  }
}

Trialex followed up with a really-big-7-segment clock (in the same thread)

• Port delay is definable. SpokePOV used to ‘guess’ what the correct delay is but I think it might be wiser to have the user tweak it as necessary
• Support for up to 32 banks of memory. What you need so much for I have no idea but hey, its there now!
• Windows version now comes with a spiffy installer. Just like Real Software!

There are a lot of great providers out there (I use Laughing Squid and highly recommend it) but even LS’s ‘largest’ package is too small for ladyada.net… What to do? Easy: Host all that bulky content at S3, then use mod_rewrite to reroute it over to S3. (You could also do it with php, asp or similar for higher ’security’ but mod_rewrite is lighter and good enough for me)

For example, this image has the url reference “http://www.ladyada.net/images/mintyboost/assemblyv12/inductorusbplace_t.jpg” but if you access that url in your browser, it is automatically rewritten by apache to http://s3.amazonaws.com/ladyadanet_mintyboost/assemblyv12/inductorusbplace_t.jpg

(same with my research pdf, a big pdf that easily accounted for 500M a day of traffic at its peak! http://www.ladyada.net/media/common/thesis.pdf -> http://s3.amazonaws.com/ladyadanet_common/thesis.pdf , S3 doesn’t care what the data is or how its encoded)

Of course mod_rewrite is not necessary, you can always just directly reference s3.amazonaws.com but that makes it harder to move the content around if you decide to eventually go with another service (or if s3 goes away one day!)

OK so, what’s the point and what does this have to do with electronics, eh? Well one of the killer apps of open source and public domain electronics is documentation. That means media. And media storage, backup and transfer is extremely expensive for the everyday person. It becomes increasingly difficult to host a project when one digg-storm or slashdotting makes that ‘free’ webpage account go down.

Edit: I use the Firefox S3 plugin to upload and set the access control on my files.

Are you using S3 or something similar for your projects, kits or documentation? Leave a comment or email! Its always interesting to see what other people are doing in this space.

Download it here (and rename it to a .php) you will need overlib.js (4.21 is what i use) installed too. An example page is here, read the source for an example.

I fixed some icky problems (in wxMIDI!) and now the MIDIsense software is crosscompiling nicely between Mac and Windows, therefore there is now fast and updated software for both platforms. Rad! Download it now!

If you wanted to try out the MIDIsense hardware but didn’t have a Mac, well I finally finished porting the wxpython code to C++ and its all much faster and more reliable. I also improved the interface and robustness. Try it out and let me know how it goes, available for download from sourceforge