Electronic – How to power an Attiny from AA batteries

First, the difference between the ATmega328p used on the Uno, and the ATtiny is mainly (for your purposes anyway), the amount of memory and flash available. The ATmega328p has 32KB Flash and 2KB SRAM. The ATtiny85 has a fourth of both, at 8KB Flash and 0.5KB SRAM.

Second, while you use the Const keyword, as others have pointed out, this works differently on Arduino/avr-gcc than it does in some other microcontrollers. My personal favorite, the MSP430, uses Const to write the variable as read only, to the code space, not to ram. The Arduino implementation does not. Having read http://arduino.cc/en/Reference/PROGMEM, it seems that the Arduino method of doing this is a bit more complex than I personally care to dive into. But…

Third, your problem mostly lies in the very inefficient char array you are using. It's a memory hog. On top of memory needed for globals, and Arduino library usage, your 23 arrays of 54 chars each takes 1242 Bytes. 1.2KB of memory are taken up, as each char in the char array takes up a minimum of a 8 bit byte! No wonder the ATtiny has a tiny fit! The Arduino Uno itself is at 75% memory capacity with the code you pasted.

There are a few ways to fix it. The first would be the Progmem above, to have these readonly arrays added to Flash and not SRAM (or use the eeprom space, that's another option). At that point, you should be below the 0.5KB SRAM limit.

The second, which might be easier for you to start, would be combining each of the 54 objects in each array, into groups of 8. Since each char takes up 8 bits of memory, and you are wasting 7 bits by only using an object that equals 0 or 1, aka a bit, combining them would save 7 bits each,** for a total usage of 161 bytes!**

const char it[] = {'1','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};

Becomes

const char it[] = {B10000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,};

This adds two pad bits at the end, still saving much memory. I used binary notation (B followed by 8 bits), but hex or decimal can be used. The your editPins changes to two embedded for loops:

void editPins(const char add[]) {
  for (int a = 0; a < 7; a++) {
     for (int b = 0; b < 8; b++) {
      if ( (add[a] >> b) & 0x01 == 1) { //(if add[a] bit shifted and 1 equals 1)
         pins[((a + 1) * (b + 1)) - 1] = '1';
      }
     }
   }
 }

My syntax may be off, but recursive loops are fine.

And the Third option, would be a not too complicated array of variables for a for loop. Your arrays are very neat, in that they have all bits set to 1 together, surrounded by 0 bits. I would have an array that goes:

char example[3] = {'number of zeros', 'numbers of ones','number of zeros'}

followed by a set of for loops:

 //set i zeros
 for (int i = 0; i < example[0]; i++) pins[i] = 0;
 //set i ones
 for (int i = example[0]; i < example[1]; i++) pins[i] = 1;
 //set i zeros
 for (int i = example[1]; i < example[2]; i++) pins[i] = 0;

Or the array would have the start index of the 1 bits, and how many 1 bits. The former option uses 3 bytes for each array (69 bytes for all 23 arrays), while the latter uses 2 bytes (46 bytes total)

A few things about your basic circuit before I address your specific questions.

i. Every IC needs a decoupling capacitor. For this circuit, that applies to the linear regulator and the microcontroller. For the microcontroller, as with most ICs, a 0.1uF capacitor between VCC and GND is typical. The capacitor should be as close as possible to the physical pins of the chip. The linear regulator takes a little more thought. Most regulator manufacturers will specify what kind of capacitors and what value to use on the input and output. This particular one does not, but they do provide a test circuit that should be good enough for your purpose:

ii. Every kind of linear regulator has a "dropout voltage" (VDO). The dropout voltage is the minimum difference in voltage between the input and the output. Your L78L05 has a dropout voltage of 1.7V. That means the minimum input must be: $$V_{INmin}=V_{OUT}+VDO=5V+1.7V=6.7V$$ Your 6V battery pack is less than 6.7V, which will not allow the regulator to regulate to 5V. Instead, you'll get something closer to 4V. That may not be a problem for this particular circuit, but you should be aware of that. There are plenty of linear regulators available with much lower than 1.7V VDOs.

Now on to your specific questions.

1. It normally doesn't matter where the microcontroller gets power during programming, as long as the power source is clean and stable. So either supply the power from your battery pack or from the programmer itself. But only choose one. If you leave the battery pack connected while enabling power from the programmer, they may conflict with each other. Whichever voltage source is slightly higher will try to push current into the other one, which won't make either one very happy. My recommendation would be to power the circuit off the battery and not the programmer. That way you don't have to keep removing the battery every time you program the board.

One possible complication here is if your circuit contains high-current components that might activate during programming. It is likely the programmer will not be able to supply enough current to keep the voltage stable if there is a lot of current draw from elsewhere. In a situation like that, it would be required to use your own power supply during programming.

2. You don't need to isolate the programmer when using the battery as long as the programmer's voltage supply is off. The only stipulation here is that the ground references of your circuit and the programmer are tied together. Otherwise, no special isolation is necessary.

3. If you do use the programmer's power, putting a diode on VOUT isn't a bad idea, but in may not be necessary. Unfortunately, the datasheet for the L78L05 does not give a absolute max voltage on the VOUT pin relative to the VIN pin. However, I have routinely applied external voltages to the output pins of unpowered linear regulators without a diode in between without problems. Without a specification in the datasheet, it's hard to know for sure. But I don't suspect you'll have a problem.

4. Yes, those are all valid concerns about adding a diode.

5. If you use the battery pack for power instead of the programmer, there are no more concerns.

6. Using resistors to isolate the other components from the programmer's pins is a common approach. However, you still need to be aware of how much current might be drawn from the programmer's pins. When a pin on the programmer goes high, the LED will light up. With a 100 Ohm resistor, a 2V LED may sink 30mA (\$(5V-2V)/100Ohm = 30mA\$). That's probably way more than the programmer's data pins can source. That's undoubtedly why the programmer is hanging up.

7. Since you can't make the resistors any larger without making the LEDs dimmer, you can use digital buffers to remove the load on the programmer pins completely. Other types of components may need different types of isolation circuitry. But resistors and buffers cover most situations.

^{simulate this circuit – Schematic created using CircuitLab}