(parenthetic)

Arduino as ISP

2012-01-09T00:17:00.000-08:00

I just burned a bootloader onto an Arduino, using another Arduino as an In System Programmer or ISP. The instructions for doing this are on http://arduino.cc/en/Tutorial/ArduinoISP. All the required software is included in the standard Arduino IDE download, and the only hardware needed is a bunch of wires.

When assembled it looked like this:

The Freetronics TwentyTen on the left is the programmer and the NKC Electronics Freeduino on the right is being programmed. The wires are braided together to make them easier to manage. On the left, they're soldered to header pins. On the right they're soldered to the end six pins of an 8x2 header pin socket I had lying around.

It turns out that everything Just Worked. After the Freeduino had a bootloader programmed, the Freeduino was able to download sketches like an Arduino should. Hooray.

You may wonder how one ends up messing around with boot loaders. If you weren't wondering, or you prefer concise stories, you can stop reading now.

I bought two Freeduino kits from Little Bird Electronics. The idea of soldering up my own Arduino was attractive, and they're cheap enough that I could buy two. Of course, the first one I assembled didn't work.

My development PC would recognize the Freeduino when it was plugged in, and I could get it to echo characters by removing the CPU and bridging the TX and RX pins. That meant that the FTDI chip was OK. However, it would not allow sketches to be uploaded and pressing the reset button did nothing. An hour of probing with a multi-meter didn't reveal any bad joints either.

I decided to be both brave and hopeful and assemble the second one. Same result.

Searching for the avrdude error message "resp 0x00" leads to ladyada's "HHHHHEEEEEEEEEEEEEEEEEEEEEEEELLLLLLLLLPPPPPPPPPPPPP!" page which indicated that a bad or missing bootloader was the likely cause.

Once again being brave and hopeful, I moved the 328P from my working Freetronics Arduino to one of the Freeduinos, and - to my amazement - it happily downloaded and ran the blink sketch. Great.

At that point it was clear that I either the 328Ps shipped with the Freeduinos were both bad (not likely) or that they had incorrect or missing bootloaders (more likely). I recalled that it was possible to use an Arduino to program other Arduinos, though I didn't realize how simple it was :)

And that's how I ended up burning a bootloader onto an Arduino via another Arduino.

Qix on LCD

2012-01-04T22:31:00.000-08:00

Graphical LCD panels are no fun without graphics, so here's a picture of the panel from the last post with a Qix-like demo.

The code (link) is still all in one file, hosted up at github. It takes a brute-force approach, using 1K of the Arduino's 2K RAM to contain a bitmap of the display's 8192 pixels. This bitmap is then painted onto the screen whenever an update is needed. I arrived at this solution because, using the serial interface, it is not possible to read the contents of the LCD unit's RAM. Since the protocol requires that 16 bits are updated with each memory set operation, drawing a line without erasing other parts of the display would be difficult without knowing what is already on the screen.

Repainting the display takes on the order of one hundred milliseconds - plenty fast enough for my needs.

There are a few tricky things I found along the way:

When the controller is first reset, the LCD unit's graphical display RAM (GDRAM) is full of garbage that needs to be overwritten.
Graphics and text are displayed simultaneously. Therefore, the textual RAM should be cleared before showing graphics.
As seems to be the way with LCD controllers, finding the GDRAM addresses corresponding to any particular pixel is a little challenging. The ST9720 can support much larger displays, and many GDRAM addresses don't correspond to on-screen pixels. The display_refresh() method looks simple, but was the result of much trial and error.

The code includes a line drawing function (algorithm) and a circle drawing function (algorithm), it also manipulates the display bitmap directly. That's most of what I'll need for my projects.

If you wanted to build a full graphics library for the ST9720, a great place to start is glcd-arduino, a comprehensive library for a range of KS108 devices. It looks like it would be possible to make it work for a serially-connected ST9720 device with a days' hacking, or less.

I stole the idea of using a 1K buffer from Mike Cochrane. As he notes, it's a bit crazy to use 1024 of the 328P's 2048 bytes of RAM just for display.

Hello, World! in Arduino with an st7920 LCD Panel

2011-12-29T00:05:00.001-08:00

These holidays, I found some time to hack on Arduino. I ordered a 128x64 graphic LCD panel from Little Bird and set about hooking it up.

After a bit of confusion - I thought I had ordered another part, with a different chipset - I eventually had the datasheet for the st9720 controller chip and another datasheet for the panel.

The controller chip has 8 bit and 4 pit parallel interfaces, as well as a serial interface. I chose the serial option, with serial signal and clock pulses generated by the ATmega328p's SPI unit. The trickiest part was getting the unit reset correctly after power on. I just wired it to PB0, and controlled it from there.

Here's the source for my first experiment - displaying text. It's C code compiled with the GNU toolchain. Comments are a little sparse, but all the really important information is at the top of the file.

/*
 * Drive an ST7920 LCD module via the serial interface.
 *
 * Data sheets:
 * - 12864ZB module http://read.pudn.com/downloads135/doc/573419/7920.pdf
 *   (in Chinese, but Google Translate is helpful)
 * - st7920 
 *   LCD controller http://www.crystalfontz.com/controllers/ST7920.pdf
 * - 328p MCU 
 *    http://www.atmel.com/dyn/resources/prod_documents/doc8271.pdf
 *
 * Configuration
 * LCD | 328/Arduino
 * ------------------------
 * GND | GND
 * VCC | 5V
 * E   | SCLK == PB5 == D13
 * RW  | MOSI == PB3 == D11
 * RST | PB0 == D8
 * RS  | 5V
 * A   | 390R to 5V
 * K   | GND
 *
 * Also bridged JP1 and JP2 to use onboard pot for contrast control.
 *
 * The trickiest part of getting this right was the control of the reset
 * pin. I found it quite finicky, and needing to be cycled just-so.
 */

#include <util/delay.h>
#include <inttypes.h>
#include <avr/io.h>
#include <avr/pgmspace.h>

void spi_init(void) {
   // SPI enable, master mode, clock idle high, sample data on trailing 
   // edge, Clock Frequency = Fosc / 8 = 2MHz
   SPCR = 0b01011101;
   SPSR = 0b00000001;

   // Set SS, MISO and PB0 as outputs
   DDRB = 0xff;
   PORTB = 0x1; // set PB0 - nonreset
}

void spi_send(int8_t b) {
   SPDR = b;
   while (!(SPSR & 0x80)) {
       // busy wait
   }
}

void lcd_instruction(int8_t ins) {
   spi_send(0b11111000); // 5 1 bits, RS = 0, RW = 0
   spi_send(ins & 0xf0);
   spi_send(ins << 4);     
   _delay_us(72); 
}  

void lcd_data(int8_t data) {
     spi_send(0b11111010); // 5 1 bits, RS = 1, RW = 0
     spi_send(data & 0xf0);
     spi_send(data << 4);
     _delay_us(72);
}  

void lcd_set_cursor(int8_t line, int8_t col) {
     // Contrary to the data sheet, the starting addresses for lines 
     // 0, 1, 2 and 3 are 80, 90, 88 and 98
     uint8_t d = 0x80 + col;
     if (line & 1) {
         d |= 0x10;
     }
     if (line & 2) {
         d |= 0x8;
     }
     lcd_instruction(d); 
}  

// Clears the screen 
void lcd_clear() {
     lcd_instruction(0b00000001); // clear
     _delay_ms(2); // Needs 1.62ms delay 
}  

// Reset, as per page 34 of 7920 data sheet 
void lcd_reset() {
      // Bring (PB0) low, then high
     PORTB &= ~0x01;
     _delay_ms(1);
     PORTB |= 0x01;
     _delay_ms(10);
     lcd_instruction(0b00110000); // 8 bit data, basic instructions
     lcd_instruction(0b00110000); // 8 bit data, basic instructions
     lcd_instruction(0b00001100); // display on
     lcd_clear();
     lcd_instruction(0b00000110); // increment, no shift 
}  

static char string_1[] PROGMEM = "Hello, World!";  

void lcd_send_str_p(PGM_P p) {
     uint8_t b;
     while (b = pgm_read_byte(p), b) {
         lcd_data(b);
         p++;
     } 
}  

int main(int argc, char **argv) {
     spi_init();
     _delay_ms(10);
     lcd_reset();
     uint8_t i = 0;
     while (1) {
       lcd_instruction(0x80);
       for (uint8_t c = 0; c < 64; c++) {
           lcd_data('1' + (c >> 4));
       }

       _delay_ms(1000);
       lcd_clear();

       lcd_instruction(0x80);
       for (uint8_t c = 0; c < 64; c++) {
           lcd_data('A' + (c >> 4));
       }
       _delay_ms(1000);
       lcd_clear();

       lcd_set_cursor(i, i);
       lcd_send_str_p(string_1);
       i = (i + 1) & 3;
       _delay_ms(1000);

   }
}