I’ve been thinking hard about selling it because I didn’t think that rooting it and installing a tweaked ROM was going to be enough to fix it. I decided to try anyway with the new Android 4 (ICS) release. It only took about five minutes using the Xoom with ICS to realize how wrong I was and how good Android 4 is for the Xoom. Everything is better.

As usual with hacking all things mobile, you will be heading over to XDA if you want your Xoom to behave like it should. I’m writing a quick tutorial here since the information is pretty spread out on XDA. I had a couple issues that had me searching through pages of threads, so this is what worked for me.

Step 1: Unlock your Xoom. You can’t do anything until this is complete, and in the process it will void your warranty and wipe your device. Back up any important data first. The instructions on unlocking your Xoom are here. After you install the Android SDK, you will need to install the Android tools and a platform (4.0) from the SDK manager. This will install fastboot, which will be in the platform tools folder you installed. You will run a command window in the folder where fastboot is located in order to send the commands to the device.

Step 2: Install a new recovery console. Use the instructions here. Use the non-CWM method. You will be sending it through adb and the command window you used earlier. There is a trick though: you can’t reboot into recovery with the adb commands unless you are already rooted, and if it’s your first time you obviously aren’t. So instead of rebooting via the fastboot command, reboot by pressing the volume up key and the power key until the screen goes black. Then count for 3.5-4 seconds after you see the Motorola logo and press volume down. “Android recovery” should appear on the screen. Press volume up to select. If the next screen you get is an Android robot with an exclamation mark, you pressed volume up into recovery too soon. Reboot, reflash the recovery file, reboot, and try again. When you get the timing right you will see the ClockworkMod screen and the recovery console.

Step 3: Root your Xoom. Once you can get into the CWM screen at will, download and install the Universal Xoom Root zip file from here. You now have control of your Xoom, it’s time to load new software on it.

Step 4: Install a new ROM. Download the latest ROM and Google apps package from here. This is the team EOS ICS ROM, you can pick from any ROMs available on XDA at this point though. Furthermore this is the wi-fi only Xoom ROM (MZ604). If you have a 3G/4G device you will need to get the appropriate ROM from XDA. Place the two zip files on your SD card and install as before, but make sure you do a factory reset first and clear the caches. After you have installed the two zip files, reboot and enjoy your Xoom.

As usual, do this at your own risk. You can ruin your device if you mess something up. If you aren’t sure about what you are doing, head over to the XDA Xoom Android development forum and start reading. This tutorial isn’t a substitute for any of the information at XDA, just a sequence of events that makes first time rooting a little easier to understand. Much respect to the developers at XDA for making this possible. Good luck!

This review will cover getting the SKDE up and running with the TCPIP Demo App from the application libraries in MPLAB X.

Download and install:

Java

MPLAB X

Microchip Application Libraries

When you run the CD that comes with the ethernet starter kit, you will have an option to install from CD. This will also install MPLAB 8. I couldn’t find a way around doing this, as the driver for the board is buried somewhere in that install. It won’t install the starter kit otherwise.

When the install is completed, start the driver switcher application from the Microchip program directory. Select PIC32 SK, and the radio button to configure for MPLAB X. Apply the setting and wait for it to complete. Then launch MPLAB X. Select Open Project from the file menu. Navigate to the Microchip Solutions directory, then TCPIP, finally select Demo App and MPLAB X. When you open the project it will start loading. It takes a while since the code stack is large. When it loads set the project configuration to the ethernet starter kit (C32-PIC32_ETH_SK). Finally you should be able to build and load the project to the target.

Once complete, plug the ethernet port into a router, where it will get an IP address. Logging on to the router will let you see attached devices and find the assigned IP. You should be able to put the IP in your browser now and see the Microchip demo page.

There are video tutorials on Microchip’s website that detail the dynamic webpage capabilities of the device. The demo application supports a lot of processors and protocols, so my next task will be to dig in and figure out the smallest code necessary to just run HTTP on the PIC32.

I did some more digging and figured out that the router doesn’t really have a WAN port, despite the port on the back being labeled as such. The switch controller is actually a six-port controller, and only five are used. Even though the WAN port on the router is physically separated from the other four ports, the switch controller sees it exactly the same as the rest. All five of the ethernet ports on the back are auto-sensing ports so any one has uplink capability. The polarity of the connection is tested during link or when more than three packets are received with inverted end-of-packet pulses. If any of the ports exhibit this behavior the switch controller reverses the port polarity and stores that status in a register. That port then becomes an uplink.

What I figured out was that if the switch ports are used for other devices, the router will eventually fail to uplink. That is, if you use it as an access point instead of a router, it’s fine. When you start using the  switch ports it gets confused. I have successfully had the router running for a while by connecting my wired devices through a switch and then uplinking just the switch to port 2, with the router then uplinking to the gateway. Evidently the router’s processor has an issue with its mapped memory.

I’ve now bought a Linksys E2500 wireless N router to replace this thing. You can get refurbished wifi routers at Cisco’s store for about half price.

Recently though the connection speed over wifi plummeted. I was going to buy a new wireless AP, but I’m pretty cashed at the moment so I took the router apart to see if I could buy some time.

You could pretty clearly see that the microprocessor has overheated. The conformal coating is brown on the bottom side of the PCB. I used an infrared thermometer to measure the temperature of the chip, it was running at about 74°C. The ethernet switch controller IC had a similar temperature, but it’s a larger leaded package whereas the CPU looks like a BGA package. I had some memory heatsinks that I cut to fit the two chips, and with that and some thermal paste I had heatsinks for the two heaters in my router case. They are low profile enough that the case will still go on.

My router works like it should again: speedtest.net reports an average of 18Mbps download speed. The heatsinks keep both ICs at about 49°C now. Guess I won’t need that new AP for a while.

So this got the lights working. Unfortunately, they aren’t all that simple to work with. The earliest version of Alienware’s command center works and allows you to set the colors, fades, etc. It won’t write to the AlienFX EEPROM though, and later versions of CC can’t communicate with the AlienFX board at all (This is a pre-Dell Alienware machine, the Dell version has different hardware). The lights are controlled by this AlienFX board (which I’m guessing lives on the motherboard), which enumerates as a USB device. Once you have an OS installed, you can try and write directly to the device. I haven’t been able to get successful EEPROM writes to the device though, and since I hacked the registry on mine to get the backlit keyboard working, the colors flash somewhat randomly during boot until Windows loads and starts the AlienFX software. Then the lights resume doing whatever you set them to. Evidently it’s writing stuff to the EEPROM, but it’s just not the right stuff.  I tried using AlienFX Lite from notebookreview.com, but I only get an error message that the packet was the wrong size.

Since I had to add a couple registry keys and reboot to force the BIOS / AlienFX controller to recognize the keyboard, I’m guessing there is another key that I’m missing to get the board to recognize the proper programming sequence. Or maybe I need a different BIOS, but I can’t find one for this older version of the m15x. I suppose I don’t really care at this point, since the FX does what I want in Windows anyway.

The only thing I’d like to fix is that with CC A03 the power light flashes off briefly every time it repeats the color cycle. It gets pretty annoying looking at the screen when the power light just below it is monotonously flashing. The way I get around this is by creating a bunch of themes in A03, and then uninstalling A03 and installing A05. A05 automatically picks up the previous theme, and uses it. If you start the AlienFX editor it crashes, so if you need to edit one of your themes you have to install A03 again. You can also edit the script but it’s cumbersome.

It turns out that the CCD wasn’t what was wrong with my camera though. Canon repaired a slew of these cameras saying that some of the CCDs they sourced were faulty. On my camera the problem was the connector on the mainboard for the CCD, not the CCD itself. The latch that locks in the CCD’s flexible circuit board was incredibly frail. I figured it out by powering up the camera while I had it apart and lightly pressing on the CCD connector. I ended up fixing it with a small piece of foam. There is just enough of a gap between the flash memory housing and the CCD connector to wedge a bit of foam and keep the CCD circuit board contacts securely connected.

The video embed didn’t seem to stay so here is the link to the video instead: http://youtu.be/9Znno5MhP2k

Of course you can always find my videos at YouTube from my channel, imsolidstate.

EDID is Extended Display Identification Data. It’s what makes your monitor “Plug and Play”. When you plug a monitor into your computer, the monitor communicates data about itself to the computer over the DDC bus, which is an I2C bus. For a DVI connection, the I2C data and clock lines are on pins 6 & 7. Usually you would flash your monitor’s EDID while it’s hooked up to your PC with a program like Powerstrip, but you have to buy the registered version of powerstrip to have that functionality. Additionally, revision 3 of the EDID specification requires the EDID to be write-protected. That means to flash the EDID with Powerstrip you need to figure out the manufacturer’s sequence for temporarily unlocking the EEPROM. Something like turning the brightness and contrast to zero, then power cycling while holding the menu button, etc. I didn’t feel like messing around with that so I just took the monitor apart.

The EDID is stored on an I2C EEPROM. With a little bit of intuition you can make out where it is on the driver board. There should be an EEPROM for every input to the monitor, as each input has it’s own EDID. On mine there was an Atmel 24C02B 2k EEPROM next to the DVI connector. I used a meter to verify the clock and data pins connection to the DVI connector. From the datasheet, pin 7 is the write protect pin of the EEPROM. It is active high, so you need to desolder the pin and use a resistor to pull the pin to ground.

Now that the write protection is permanently disabled, you can write to the EDID directly over the I2C bus. To interface with the monitor, cut the end off of an old DVI cable. Use a meter to find the I2C clock and data lines. You will also want to find +5V and ground (pin 14 & 15). I then connected those pins to the corresponding pins on my mbed.

The reason I used my mbed was because there is a pre-written mbed program (I2C debug for RealTerm) that uses the I2C GUI buttons in realterm. I use realterm exclusively as my terminal program, it’s absolutely excellent for blindly hacking a serial interface. So it was an easy choice.

Import the I2C debug program into the mbed editor, and then compile it and save it to the mbed. Open realterm and set it to 9600,8,N,1 on the virtual COM port your mbed uses (you may have to install the driver for this). Connect the DVI cable to the monitor (double-check your power lines first!) and reset the mbed. The mbed should tell you in realterm that it is ready and found a device at address A0 or something similar. You can now send and receive commands via the interface. Refer to the datasheet for your particular EEPROM, but all I had to do to overwrite values was write the address and the new byte value in the “write” box. My monitor needed to be corrected from 1D (290mm vertical) to 1E (300mm vertical). Remember that changing a value will require re-calculation of the checksum. If you are just changing one value, it’s easy to just add or subtract the checksum with the amount you changed the other value by. In my case I added 1 so I subtracted 1 from the checksum. If you are doing a more significant edit, just import your EDID values into excel. You can then convert the values to decimal, sum the values and perform a modulus by 256. You should get zero as the result. The checksum makes the sum of the 128 byte EDID equal to zero. If you don’t get zero then modify the checksum until you do. If your checksum is incorrect it won’t be accepted by windows, which will label it in the registry as “BAD_EDID” if I remember right. When you’re done writing the new values, write an address of 0×00 and the read out 128 bytes. Verify your data. Your done!

The active area of the pad is approximately 2′ x 2′. I think the foam is polyurethane open-cell foam but I’m not sure. It’s the stuff you use to pack shipping crates. The load cells are made by sandwiching the foam in between 1″ circle cutouts of copper-clad FR4 PC board. I used single sided board and a hole saw with the pilot bit removed (use a drill press and a clamp). The capacitance varies as the foam compresses, and the amount of capacitance is directly related to the thickness and density of the foam, as well as the area of the copper conductors (plates). So you can create any size or thickness load cell you want really. A bigger plate results in more capacitance, as does placing the plates closer together. I estimated the capacitance I would have in my application with this calculator I found at Daycounter engineering services.

I created an array of 64 cells by making 8 rows and 8 columns, each with 8 copper-clad discs. Wherever the row/column discs align a load cell is created. An AVR typically has eight available ADC inputs along with another eight control outputs, so this way you can scan down through the rows and columns to measure each cell. A square wave is sequentially output on the columns, and after some analog proccessing the AVR’s ADC scans each row. The analog voltage present represents the amount of pressure (capacitance) at each site.

The square wave generator is the old two op-amp ramp generator/comparator circuit. This is fed to one side of the cell. The output from the other side is coupled through whatever capacitance is available at the cell, and results in a triangle wave with amplitude proportional to the capacitance thanks to a transimpedance amplifier. Then it is fed to a peak detector and amplified. The signal is then sent to the ADC. There are more than a few examples out on the web for capacitance sensing, here is a good one.

The AVR outputs the 64 values on a serial port. I used excel’s surface chart to represent the data. The chart posted here is a map of an english saddle.

It works fairly well, but my analog section needs some improvement. Sensitivity is sufficient for this test, but it’s relatively poor. Response time also suffers because of noise; my prototype could definitely use improvement in that area and I had to decrease the response time of the amplifier to get consistent output. This is unfortunate because I had planned on trying to make a movie by recording real-time data while riding a horse. I even designed it to run on a 9V battery for this purpose. Maybe if I have enough free time next summer (unlikely) I’ll try and tune it up a bit.

I planned on just having the AVR recognize a particular text string, like “open garage” if I wanted to let someone in my house when I’m not there without giving them a key for example. It’s not overly secure, but you could add a number sequence as a prefix to the command that would be like a password. Then you could periodically change your password if you wanted.

I’m using cell phones from Siemens. They are older phones with true serial comms. You can score one for $20 or so from ebay. The only thing that sucks about these phones is they use PDU mode for text messages. It’s a really inconvenient way to send text strings. There’s a ton of setup to each packet and each character is encoded in seven bits. I haven’t been able to get my code working with the PDU method yet. It gets stuck trying to decode the received message. I’m going to post it here to see if anyone has any suggestions.  I’m all self-taught in C. I’ve never tried comparing strings before, so that bit is a little cumbersome. I don’t like using the built-in libraries to do that kind of stuff until I figure out how it works. The only thing I think turned out nice in the code is the unpacking function.

Obviously, you’d be ahead of the game if you found a serial-interface phone that used the regular text mode instead of PDU. I couldn’t find any phones that did text mode and didn’t have a USB interface. (at least not for cheap) Programming a USB host interface is beyond my capabilities on the AVR.

References: Developer’s Home SMS Tutorial

#include <avr/io.h>
#include <avr/interrupt.h>

#define unpack_state1 0
#define unpack_state2 1
#define unpack_state3 2
#define unpack_state4 3
#define unpack_state5 4
#define unpack_state6 5
#define unpack_state7 6
#define unpack_state8 7
#define F_CPU       8000000
#define BAUD   9600
#define MYUBRR  (F_CPU/(BAUD*(unsigned long)16))-1

void init_USART(void);
void init_timer0(void);
void turnoff_timer0(void);
void init_timer1(void);
void check_sms(void);
void decode_sms(void);
char unpack(unsigned char octet);
void USART_write(unsigned char *buf);

volatile unsigned char rcv_buf[128];
volatile unsigned char rcv_buf_idx;
volatile unsigned char check_message, check_online;

void main(void)
{
 DDRD |= 0x03;
 PORTD &= ~0x03;
 DDRC |= 0x3F;
 PORTC &= ~0x3F;
 DDRB |= 0x3F;
 PORTB &= ~0x3F;
 init_USART();
 init_timer0();
 sei();

 while(check_online<0xF7)
 {
  rcv_buf_idx= 0x00;
  USART_write("at");
  while((rcv_buf_idx<0x08)&(check_online<0x30)) {}
  if( rcv_buf[0x05]==0x4F &
   rcv_buf[0x06]==0x4B)
  {
   PORTB &= ~(1<<PORTB0);   //diagnostic leds
   PORTB &= ~(1<<PORTB5);   //diagnostic leds
   check_online= 0xFA;
  }
  else
  {
   if(rcv_buf_idx<0x01) PORTB |= (1<<PORTB5);
   PORTB |= (1<<PORTB0);
   while(check_online<0xF4){} //8s
   check_online= 0x00;
  }
 }
 turnoff_timer0();
 init_timer1();

while(1)
 {
  if(check_message) check_sms();
 }
}

ISR(USART_RX_vect)
{
 rcv_buf[rcv_buf_idx]= UDR0;
 rcv_buf_idx++;
}

ISR(TIMER0_OVF_vect)
{
 check_online++;
}

ISR(TIMER1_OVF_vect)
{
 check_message= 0x01;
}

void init_USART(void)
{
 UCSR0B |= (1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
 UCSR0C |= (1<<UCSZ00)|(1<<UCSZ01);

 UBRR0L = MYUBRR;
 UBRR0H = (MYUBRR >> 8);
}

void init_timer0(void)
{
 TCCR0B |= (1<<CS00)|(1<<CS02);  //clk/1024
 TIMSK0 |= (1<<TOIE0);
}

void turnoff_timer0(void)
{
 TCCR0B &= ~((1<<CS00)|(1<<CS02));  //clk/1024
 TIMSK0 &= ~(1<<TOIE0);
}

void init_timer1(void)
{
 TCCR1B |= (1<<CS10)|(1<<CS12);  //clk/1024
 TIMSK1 |= (1<<TOIE1);
}

void check_sms(void)
{
 rcv_buf_idx= 0x00;
 USART_write("at+cmgl");
 while(TCNT1<0x90) {}
 if( rcv_buf[0x0A]==0x4F &
  rcv_buf[0x0B]==0x4B) {PORTB &= ~(1<<PORTB1); PORTB &= ~(1<<PORTB5);}
 else if(rcv_buf[0x0A]=='+' &
   rcv_buf[0x0B]=='C' &
   rcv_buf[0x0C]=='M' &
   rcv_buf[0x0D]=='G' &
   rcv_buf[0x0E]=='L' &
   rcv_buf[0x0F]==':') {PORTB &= ~(1<<PORTB1); PORTB &= ~(1<<PORTB5); decode_sms();}
 else
 {
  PORTB |= (1<<PORTB1);
  if(rcv_buf_idx<0x01) PORTB |= (1<<PORTB5);
 }
 check_message= 0x00;
}

void decode_sms(void)
{
 unsigned char offset;
 while(rcv_buf_idx<0x17){}
 unsigned char lenTPDU= (((rcv_buf[0x16] &= ~0x30)*10) + (rcv_buf[0x17] &= ~0x30));
 lenTPDU*= 2;
 while(rcv_buf_idx<0x1B){}
 unsigned char lenSMSC= (((rcv_buf[0x1A] &= ~0x30)*10) + (rcv_buf[0x1B] &= ~0x30));
 lenSMSC*= 2;
 offset= 0x1B;
 while(rcv_buf_idx<(lenSMSC+offset+lenTPDU)){}
 //ignore SMSC part
 //ignore first byte
 offset= 0x1E;
 unsigned char len_sender_number= ((rcv_buf[offset+lenSMSC] &= ~0x30)*10);
 offset= 0x1F;
 if((rcv_buf[offset+lenSMSC]>0x2F) & (rcv_buf[offset+lenSMSC]<0x3A))
  len_sender_number+= (rcv_buf[offset+lenSMSC] &= ~0x30);
 else if(rcv_buf[offset+lenSMSC]=='A') len_sender_number+= 10;
 else if(rcv_buf[offset+lenSMSC]=='B') len_sender_number+= 11;
 else if(rcv_buf[offset+lenSMSC]=='C') len_sender_number+= 12;
 else if(rcv_buf[offset+lenSMSC]=='D') len_sender_number+= 13;
 else if(rcv_buf[offset+lenSMSC]=='E') len_sender_number+= 14;
 else if(rcv_buf[offset+lenSMSC]=='F') len_sender_number+= 15;
 if(len_sender_number%2) len_sender_number++;
 rcv_buf_idx= (0x1B+lenSMSC);
 unsigned char i= len_sender_number;
 while(i)
 {
  unsigned char *sender_number= rcv_buf[++rcv_buf_idx];
  sender_number++;
  *sender_number= rcv_buf[--rcv_buf_idx];
  sender_number++;
  rcv_buf_idx += 0x02;
  i-= 0x02;
 }
 offset= 0x35;
 unsigned char num_septets= ((rcv_buf[offset+lenSMSC+len_sender_number] &= ~0x30)*10);
 offset= 0x36;
 if((rcv_buf[offset+lenSMSC+len_sender_number]>0x2F) & (rcv_buf[offset+lenSMSC+len_sender_number]<0x3A))
  num_septets+= (rcv_buf[offset+lenSMSC+len_sender_number] &= ~0x30);
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='A') num_septets+= 10;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='B') num_septets+= 11;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='C') num_septets+= 12;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='D') num_septets+= 13;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='E') num_septets+= 14;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='F') num_septets+= 15;
 offset= 0x37;
 rcv_buf_idx= (offset+lenSMSC+len_sender_number);
 unsigned char loop= 0;
 unsigned char message[16];
 unsigned char message_idx= 0x00;
 offset= 0x1C;
 while(rcv_buf_idx<=(offset+lenTPDU+lenSMSC))
 {
  unsigned char octet= 0;
  if(rcv_buf[rcv_buf_idx]=='A') octet |= 0xA0;
  else if(rcv_buf[rcv_buf_idx]=='B') octet |= 0xB0;
  else if(rcv_buf[rcv_buf_idx]=='C') octet |= 0xC0;
  else if(rcv_buf[rcv_buf_idx]=='D') octet |= 0xD0;
  else if(rcv_buf[rcv_buf_idx]=='E') octet |= 0xE0;
  else if(rcv_buf[rcv_buf_idx]=='F') octet |= 0xF0;
  else octet= ((rcv_buf[rcv_buf_idx] &= ~0x30)*10);
  rcv_buf_idx++;
  if(rcv_buf[rcv_buf_idx]=='A') octet |= 0x0A;
  else if(rcv_buf[rcv_buf_idx]=='B') octet |= 0x0B;
  else if(rcv_buf[rcv_buf_idx]=='C') octet |= 0x0C;
  else if(rcv_buf[rcv_buf_idx]=='D') octet |= 0x0D;
  else if(rcv_buf[rcv_buf_idx]=='E') octet |= 0x0E;
  else if(rcv_buf[rcv_buf_idx]=='F') octet |= 0x0F;
  else octet+= (rcv_buf[rcv_buf_idx] &= ~0x30);
  rcv_buf_idx++;
  message[message_idx]= unpack(octet);
  message_idx++;
  if(++loop==7)
  {
   message[message_idx]= unpack(0x00);
   message_idx++;
   loop=0;
  }
 }
 if( message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='1' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<<PORTB2); PORTC |= (1<<PORTC0);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='1' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='f' &
  message[0x0A]=='f') {PORTB &= ~(1<<PORTB2); PORTC &= ~(1<<PORTC0);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='2' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<<PORTB2); PORTC |= (1<<PORTC1);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='2' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='f' &
  message[0x0A]=='f') {PORTB &= ~(1<<PORTB2); PORTC &= ~(1<<PORTC1);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='3' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<<PORTB2); PORTC |= (1<<PORTC2);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='3' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='f' &
  message[0x0A]=='f') {PORTB &= ~(1<<PORTB2); PORTC &= ~(1<<PORTC2);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='4' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<<PORTB2); PORTC |= (1<<PORTC3);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='4' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='f' &
  message[0x0A]=='f') {PORTB &= ~(1<<PORTB2); PORTC &= ~(1<<PORTC3);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='5' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<<PORTB2); PORTC |= (1<<PORTC4);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='5' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='f' &
  message[0x0A]=='f') {PORTB &= ~(1<<PORTB2); PORTC &= ~(1<<PORTC4);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='6' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<<PORTB2); PORTC |= (1<<PORTC5);}
 else if(message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='6' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='f' &
  message[0x0A]=='f') {PORTB &= ~(1<<PORTB2); PORTC &= ~(1<<PORTC5);}
 else PORTB |= (1<<PORTB2);
}

char unpack(unsigned char octet)
{
 static unsigned char unpack_state, remain_val;
 unsigned char septet, masked_val;

 switch(unpack_state)
 {
  case unpack_state1:
   septet= (octet & 0x7F);
   remain_val= (octet & 0x80);
   unpack_state= unpack_state2;
   break;
  case unpack_state2:
   masked_val= (octet & 0x3F);
   septet= (masked_val<<1) | (remain_val>>7);
   remain_val= (octet & 0xC0);
   unpack_state= unpack_state3;
   break;
  case unpack_state3:
   masked_val= (octet & 0x1F);
   septet= (masked_val<<2) | (remain_val>>6);
   remain_val= (octet & 0xE0);
   unpack_state= unpack_state4;
   break;
  case unpack_state4:
   masked_val= (octet & 0x0F);
   septet= (masked_val<<3) | (remain_val>>5);
   remain_val= (octet & 0xF0);
   unpack_state= unpack_state5;
   break;
  case unpack_state5:
   masked_val= (octet & 0x07);
   septet= (masked_val<<4) | (remain_val>>4);
   remain_val= (octet & 0xF8);
   unpack_state= unpack_state6;
   break;
  case unpack_state6:
   masked_val= (octet & 0x03);
   septet= (masked_val<<5) | (remain_val>>3);
   remain_val= (octet & 0xFC);
   unpack_state= unpack_state7;
   break;
  case unpack_state7:
   masked_val= (octet & 0x01);
   septet= (masked_val<<6) | (remain_val>>2);
   remain_val= (octet & 0xFE);
   unpack_state= unpack_state8;
   break;
  case unpack_state8:
   septet= (remain_val>>1);
   unpack_state= unpack_state1;
   break;
 }
 return septet;
}

void USART_write(unsigned char *buf)
{
 while(*buf)
    {
       while ( !( UCSR0A & (1<<UDRE0)) ){}
       UDR0= *buf;
       buf++;
    }
 while ( !( UCSR0A & (1<<UDRE0)) ){}
 UDR0= 0x0D;
}

The scan head sensor is actually pretty cool, and by definition it’s a line scan camera. It would still be cool to set it up as a line scan camera to play with.

After seeing this rig at HAD, I’m convinced I’m wasting my time. Moving forward I will be designing a stepper-driven tripod mount for my camera and use stitching software instead. If anybody has any suggestions on good software to try let me know. I’ve been using Panorama Maker or whatever the Nikon bundled program was called. It just doesn’t always do a very good job, even with the special mount I made that’s supposed to eliminate parallax. I get a lot of blurring at the upper and lower edge stitches. I would also like to experiment with multi-row so I can use longer lenses.