(Updated June 6, 2010)

The iCruze is a 2 line LCD display that was made by Monster for an iPod stereo interface. It was a MONSTER FLOP!!!

Several people including myself having been trying to use it for a general purpose LCD display with the Arduino or other micro-controllers.

iCruze Specs

• 2 Line text LCD
• Atmel Attiny26L processor
• 2 K of flash
• 128 bytes of EEPROM
• 128 bytes of RAM

• 1 Ground
• 2 MOSI
• 3 MISO
• 4 SCLCK
• 5 RESET
• 6 Vcc (+ 5)

I have successfully connected an ATMEL AVR ICSP programmer to it and was able to read the chip.

Thanks to EB4APL in Spain for the iCruze schematic

Memory dump and assembly listing of original iCruze software

The Attiny26 has a USI port which is a very bad serial interface. It HALF implements I2C (TWI), HALF implements the SPI interface and does about 1/4 of the work for a UART. There are some good ap notes on the Atmel site for using it AVR307 for the UART. But I could not get any of them to work reliably.

I was able to get I2C working EXCEPT, I had to slow the bus down on the master for it to recognize it and then the code did not handle addressing and it would print anything sent to any I2C address.

I wrote a simple software bit-banged receive which worked but not at full speed.

I have implemented an interrupt driving bit-bang receive hard coded to 9600 baud. It seems to work perfectly with my testing so far. Refer to my source code for theory of operation.

Development

• Development platform: ECLIPSE (on MacOSX)
• Programmer usbtiny from Sparkfun
• Code: Straight AVR C (no C++)

Serial communications

• 9600 baud (hard coded, sorry but not enough memory for much else)
• Standard ASCII (CR, TAB, FF, BS, VT)
• Carriage return generates auto Line Feed, Line Feed is ignored
• Shift In / Shift Out ( ^O=0x0f / ^N=0x0e) select alternate character set (Japanese and Spanish). The character sets are built into the display.

Memory Footprint

AVR Memory Usage
----------------
Device: attiny26

Program:    1508 bytes (73.6% Full)
(.text + .data + .bootloader)

Data:         90 bytes (70.3% Full)
(.data + .bss + .noinit)

This guy in Spain started the process of hacking the iCruze, he figured out the schematic. I found some on ebay and got 20 of them REAL CHEAP.

Since the controller board used an Atmel AVR chip and I have been doing a lot of Arduino and AVR programming I took it on as a challenge.

The process was as follows:

• The first step was to see what could be done with it as is. I tried connecting it via I2C and serial at many baud rates on both input pins, but the display never responded. Referring to the web page above, it probably is something weird since it sends a pulse out every 1.6 seconds.

• Next determine how to talk to the chip. There happened to be an unused connector on the board with 6 pins. I determined that those pins were indeed the ICSP programming pins. COOL!!!
  
  In this picture I have added a right angle header onto the 6 pins

• Next, fire up avrdude and see what we can figure out. Sure enough, I could read the program DOUBLE COOL!!
  The command to talk to the icruze was

  	avrdude -c usbtiny -p t26 -t
  	

  
  In this picture the usbtiny ICSP adapter is connected to the 6 pins on the controller board

• I disassembled the program and started to figure out what it did. I decided that it would probably easier and quicker to start over from scratch.

• EB4APL's web site had the LCD controller chip listed, a quick google search confirmed that it was compatible with the LCD controller used by the Arduino LCD library. COOL!!! HY-1602F.pdf spec sheet on the LCD controller

• OK, now it's time to learn the chip. It's an AVR so I am already mostly familiar with it and have the necessary development tools. But it is a different version. So go to the Atmel site and find the Attiny26 docs

• Write a program to try to control the LCD. Also, write a simple bit-bang serial output so we can do some debugging if the LCD doesn't work right away.

• I got the bit-banged serial output working right away but I really didn't need it because the LCD code worked almost first shot. I did major striping out of the library. I copied only the routines that I needed, got rid of the C++ and hard coded all of the pin assignments. Remember, we have VERY LITTLE MEMORY. So get rid of everything that is not needed.

• Next is what should have been the easy part but turned out to be the hardest of all, get the communications working. I wanted to use I2C. The Attiny has a "USI" port, Universal Serial Interface, and I found it almost useless.

• There are some good ap notes from Atmel about using the USI port but I could not get them to work reliably. I did get I2C to work but it would freeze after receiving some where between 50 and 100 characters. Also it did not have addressing implemented

• Next I wrote a simple bit-bang receive. It worked fine at typing speed but lost sync at full speed when it got a carriage return.

• So I needed an interrupt driven routine to do bit-banging. The USI port has an 8 bit shift register that can be used for serial I/O but I found it more complicated than it needed to be and decided to just do it in software.

• The Attiny26 has 2 counter/timer ports so I took advantage of them. I wasn't using them for anything else.

• Receive code Theory of operation
  • The clock timer is counter/timer 0 = 8000000 / 8 = 1 us per count. This is used for a timer standard to watch the time between bits.
  • Use an interrupt to check the input pin at least 6 x per bit time, thats 6 interrupts in 104 us. I am using the Compare 1 interrupt when the counter gets to the value, it generates an interrupt the interrupt resets the counter. It will generate an interrupt 6 times for each bit
  • The interrupt routine is a state machine that watches for a low. Once it finds a low, it waits for 1/3 bit time. If the bit is high during this time, it sets it back to idle and ignores it
  • It then waits ONE FULL bit time (starting from 1/3 bit time after the start of the start bit) 8 times and puts the bit in at bit #7 (serial data is LSB first) and shifts the previous data.
  • Once it has the 8 bits, it puts it into the buffer
  • Then it waits for the line to be HIGH and puts it back to IDLE

• Getting this interrupt driven code to work reliably took 2 days.

• Now it's available for anyone to use, enjoy....

Option 1: If you have Eclipse, WinAVR or any other AVR development environment you can download the source and proceed as you normally would. Note, this will NOT work with Arduino IDE. The size limitations do not allow a bootloader to be present so Arduino cannot be made to work.

Option 2: If you have an ICSP programmer, you can program from the HEX file that is included in the above ZIP file. Below is how to use avrdude to program it. I use a "usbtiny" USB->ICSP programmer.

Either way you will need a ICSP programmer of any type.

$ avrdude -c usbtiny -p t26 -U flash:w:icruzeLCD.hex 


avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.01s

avrdude: Device signature = 0x1e9109
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "icruzeLCD.hex"
avrdude: input file icruzeLCD.hex auto detected as Intel Hex
avrdude: writing flash (1708 bytes):

Writing | ################################################## | 100% 1.45s



avrdude: 1708 bytes of flash written
avrdude: verifying flash memory against icruzeLCD.hex:
avrdude: load data flash data from input file icruzeLCD.hex:
avrdude: input file icruzeLCD.hex auto detected as Intel Hex
avrdude: input file icruzeLCD.hex contains 1708 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.89s



avrdude: verifying ...
avrdude: 1708 bytes of flash verified

avrdude: safemode: Fuses OK

avrdude done.  Thank you.

If you cut the RJ-11 connector off the end of the cable you have 4 wires

• Black = Ground
• Red = +V 5 V if you bypass the regulator
• Green = unused (TX data if you turn debugging on)
• Yellow = Reveive data 9600 baud TTL level 8 data bits, no parity, 1 or 2 stop bits

If you look closely you can see an orange wire connecting the red wire to pin 6 on the right angle connector.
This bypasses the 7805 regulator.

Here it is connected to an Arduino.

RJ-11 pin numbers

• 1-Not Connected
• 2-RXD (YELLOW WIRE) Data out from your Arduino or other device, this is a 5V signal
• 3-Not Connected
• 4-+5 (RED WIRE)
• 5-Ground (BLACK WIRE)
• 6-Not Connected

RJ-45 pin numbers

• 1-Not Connected
• 2-Not Connected
• 3-RXD (YELLOW WIRE) Data out from your Arduino or other device, this is a 5V signal
• 4-Not Connected
• 5-+5 (RED WIRE)
• 6-Ground (BLACK WIRE)
• 7-Not Connected
• 8-Not Connected

• There is about 500 bytes of code space left but zero ram left.
• Someone could try to get I2C working with the Atmel ap notes.
• Someone could try to get the USI uart code working, also an Atmel Ap note
• None of the EEPROM has been used (128 bytes)
• Continue trying to figure out what the original code did.