Arduino dies after activating a 5th led

Bryan Chung had a tutorial still available on the Internet Archive on how to connect a LED Matrix to an Arduino using a MAX7219:

Here is an experiment with an 8×8 LED matrix, driven by a MAX7219 IC, controlled through an Arduino micro-controller board. A custom PCB has been made by Tan from DinoTech to tidy up all the wires connecting the LED matrix and the IC. It comes with a separate 12V power supply, in order not to drain everything from the Arduino board.

Only 4 wires are necessary to control the MAX7219 driver IC. They are the

Data Clock Latch/load Ground

The data and clock pins should match those for the shiftOut() command in Arduino. The latch pin will give a LOW to HIGH pulse after the shiftOut command. I have written the original program for Javelin Stamp. Since Arduino can only shift 8 bits of data, I have to use 2 separate commands to shift both the upper and lower bytes to the MAX7219, which needs a 2 bytes control for each command.

For the data structure of the 8×8 LED matrix, I use a byte array – matrix of length 8. Each row in the matrix corresponds to the Y dimension. Each bit in a row corresponds to the X dimension. Digit 1 is on; 0 is off. The X direction is reversed and there is also an 1 bit shift. The updateLED() function caters for this.

The first program is an animation of a single line motion.

int CLOCK = 12;
int LATCH = 13;
int DATA  = 11;
byte matrix[8];
int idx = 0;

void setup() {
  pinMode(CLOCK, OUTPUT);
  pinMode(LATCH, OUTPUT);
  pinMode(DATA,  OUTPUT);
  digitalWrite(CLOCK, LOW);
  digitalWrite(LATCH, LOW);
  digitalWrite(DATA,  LOW);
  initLED();
  clearLED();
}

void loop() {
  for (int j=0;j<8;j++) {
    updateLED(idx, j, true);
  }
  refreshLED();
  delay(200);
  for (int j=0;j<8;j++) {
    updateLED(idx, j, false);
  }
  refreshLED();
  delay(100);
  idx++;
  idx %= 8;
}

void ledOut(int n) {
  digitalWrite(LATCH, LOW);
  shiftOut(DATA, CLOCK, MSBFIRST, (n>>8));
  shiftOut(DATA, CLOCK, MSBFIRST, (n));
  digitalWrite(LATCH, HIGH);
  delay(1);
  digitalWrite(LATCH, LOW);
}

void initLED() {
  ledOut(0x0B07);
  ledOut(0x0A0C);
  ledOut(0x0900);
  ledOut(0x0C01);
}

void clearLED() {
  for (int i=0;i<8;i++) {
    matrix[i] = 0x00;
  }
  refreshLED();
}

void refreshLED() {
  int n1, n2, n3;
  for (int i=0;i<8;i++) {
    n1 = i+1;
    n2 = matrix[i];
    n3 = (n1<<8)+n2;
    ledOut(n3);
  }
}

void updateLED(int i, int j, boolean b) {
  int t = 1;
  int n = 0;
  int m = 0;
  if (j==0) {
    m = 7;
  }
  else {
    m = j-1;
  }
  n = t<<m;
  if (b) {
    matrix[i] = n | matrix[i];
  }
  else {
    n = ~n;
    matrix[i] = n & matrix[i];
  }
}

I have worked on building a homemade quarocopter for my final year project, I remember having trouble with this too :)

I have used Turnigy Plush 30amp Speed Controllers.

Frist of all, FYI:

The normal sequence when staring an ESC (again, the one I worked with) is:

1. as soon as your ESC is powered - minimun throttle (close to 1ms pulse) for about 3 seconds (until the beep codes for battery type and ok to start are elapsed)

This is a safety feature - normally, this means that the throttle stick is at minimum. However, a great majority of Electronic Speed Controllers are programmable in terms that you have to program this minimum (and maximum) throttle I said earlier about. In other words maybe that programmed minimum throttle is around 0.7ms (if you programmed it from RC transmitter with trim set to minimum) and when you power on your ESC input is around 10ms pulse, it's a safety feature it won't start, since in this case throttle is not minimum.

In order to program the new maximum and minimum input values (calibration):

1. Power On
2. as soon as you ESC is powered - maximum throttle (close to 2ms pulse) again wait for the beeps (only battery type)
3. quickly jump to minimum throttle (close to 1ms pulse) and wait again for the new initialization beeps (this time there will be less, without battery type)
4. new values for minimum and maximum throttle are now stored

I strongly recommend you use this kind of initialization every time so that all ESCs will be synchronized regarding minimum and maximum value of throttle. Also I strongly recommend you don't have any propellers mounted when experimenting with this approach :)

Now, regarding your code,

• I don't think you need to slide all the way up to the maximum or to down to the minimum during the initialization phase (in my case ESC expects value ASAP, with no slides), you should write the output value directly(no slide up/down).
• As soon as you reach the maximum value you start sliding down to the minimum. You should stay long enough at maximum value (Around 1 second)
• If initialization is not OK on first try, ESC is locked until supply is cut and turned on back again. There is no point in making attempts to initialize if first attempt is failed.

When calibrating or starting the ESC be sure to hold minimum value and/or maximum value as long as it is required. Something like:

Normal starup(as you described your ESC):

• Turn On ESC
• minimum throttle
• wait 2 seconds
• maximum throttle
• wait 2 seconds
• minimum throttle
• wait 1 second
• OK to Go

Normal starup(the ESC I used):

• Turn On ESC
• minimum
• wait 3 seconds
• OK to Go

Calibration:

• Turn on ESC
• maximum
• wait 2 sec
• minimum
• wait 1 sec
• OK to go

Another thing, good to know, entering programming mode for ESCs allows you to set a lot of parameters such as the cutoff threshold, brake. Before attempting flight, you must be sure that all these parameters are set the same for all ESC you use. Again, for the ESC I used, see the manual, page 2.

I'm pretty sure you've already figured this out, but I wanted to post it maybe it will help others :)