Interfacing an optical mouse (USB) with a PIC (which doesn't have USB CONTROLLER!)

se preferite la versione in italiano la trovate nel post precedente :p

if you want to copy, share, use etc. etc. all or part of this article you CAN DO IT, BUT please cite me and share the link to this article.

I'm not taking any responsibility for any kind of damage to your mouse, your PIC or yourselves XD

and yes, I posted this article on grix.com too (written in Italian).

OK, LET'S GO! :)

I needed a cheap (and accurate) motion sensor... What could be better than an optical mouse for the job? BUT... my PIC doesn't have a usb controller (and I'm cheap, so I don't want to buy a new one :p ) so I had to do things my way... :)

Description

let's start with... “an optical mouse, how does it work????”

finding a useful mouse could be a bit hard: I've spent weeks trying to open up all the mice I could find (kindly offered by friends, parents etc. etc.), so I learnt what kind of chips you can get from a usb optical mouse:

the “made in china” mice contain chips that use the computer for motion processing... that kind of mouse doesn't work well with my code, but you can find a good mouse in second-hand shops or places like that.

The mice I've tried, with good results, are based on ADNS2051 and ADNS2610 chips.

                          

I think that there are probably other mice using the same protocol (or quite similar), but I only tried with those two chips. For the purposes of this article, I shall illustrate how to use the ADNS2610 chip.

these chips are EXTREMELY sensitive to the polarity inversion: I broke a mouse just because I messed up with the polarity, so CHECK THE DATASHEET BEFORE YOU START! And check and re-check all the wires!

You can supply the chips with VDD – GND pins by soldering the wires directly on to the pins: in that way you can easily re-convert the sensor to a “common mouse” because this is the only modification that you have to make to the mouse itself.

The protocol used for the mouse-pc communication is a serial, bi-directional, half-duplex clock driven (the clock is generated by the PIC and shared both by the mouse and the PIC). Then, for the connection, you can use two wires: SCK pin (the clock) and SDIO pin (data line). So you have to solder just 4 wires in total: 2 for supply and 2 for communication.

This is a picture of the mouse that I used, after the mod:

how it works: theory of operation

After the connection phase, let's see how the mouse works.

An optical mouse is based on “Optical Navigation Technology”: it contains an Image Acquisition System (IAS) and a Digital Signal Processor (DSP).

A mouse reads any motion by acquiring sequential images by IAS module and mathematically confronting these images to determin the displacement (by DSP module).

In the next image you can see the logical architecture, where DSP and IAS are both integrated in the "IMAGE PROCESSOR".

The next diagram is of the inside of the mouse:

The displacement data is automatically stored in the registers of the chip... but how can we retrieve this data?

Communication protocol

The protocol used by ADNS2051 is harder to understand than the one used by ADNS2610 this is because it requires an initialization phase and a check on a state register before every reading.

The communication protocol is quite similar in every chip I've seen, so if you can understand the theory of operation you will be able to use any kind of mouse chip.

A serial communication is used for the read/write operations on the registers of the mouse chip and to read displacement informations (this is what we are interested in).

The communication is always initiated by the microcontroller.

A read operation, meaning data that is going from the ADNS-2610 to the microcontroller, is always initiated by the microcontroller and consists of two bytes. The first byte that contains the address is written by the microcontroller and has a “0” as its MSB to indicate data direction. The second byte contains the data and is driven by the mouse chip. This is a byte of data (two's complemented), in which the first bit is coding the sign and the other seven bits encode the displacement data since the last reading.

The maximum amount of displacement that a mouse can “feel” from reading to reading is formed by 7 bits (8 in total, but one of them is just for the sign) so 2^7=128.

The transfer is synchronized by SCK. SDIO is changed on falling edges of SCK and read on every rising edge of SCK. (look at the code below, it's simpler!). There are minimum timing requirements between read and write commands on the serial port: we have to ensure that the ADNS-2610 has at least 100 μs to prepare the requested data.

In the following image you can see the ADNS2610 registers:

The 0x08 register is quite interesting and useful since you can read the pixel seen by the mouse sensor by means 324 consecutive reading according to the following table. (the return value will represents the pixel intensity)

Practice – the circuit

The table basically shows a 16F877 PIC clocked at 4Mhz. I used the E-port for the mouse connection and the B-port for a 16x2 characters LCD (everything works fine at 5v).

the assembling phase:

Practice – the code

I wrote the code in MikroC language (you can find it attached at the end of this article).

This is the “hello world” of my project: in this way you can retrieve the coordinates and... do what you want to do with this data.

Let's start with the main(), which reads the value of the registers and writes it on the LCD (in a loop, after the port and LCD initialization).

The register contains a two's complement value, so you can simply add this value, which is only the displacement from the last reading phase, to the “global/final position”.

---

void main(){
        init_LCD_PIC();

        for(;;) {
          x += readRegister(DX);
          y += readRegister(DY);
          
          LCDWriteResult(x,y);
        }
}

---

This code reads from the register (THIS IS THE CORE OF THE PROJECT):

---

signed short readRegister(const register unsigned short int address){
        signed short output = 0;
        signed short i = 0;
  
        //direction WRITING
        DIRDATA = OUT;

        //write address of register to be read
        for(i=7;i!=-1;i--){
            MOUSE_CLK = 0;
            MOUSE_DATA = 1 && ((address & (1<<i))>0);
            MOUSE_CLK = 1;
        }

        //direction READING
        DIRDATA=IN;

        //wait for data
        Delay_us(100);
  
        //read the data
        for(i=8;i!=0;i--)  {
           MOUSE_CLK = 0;
           MOUSE_CLK = 1;
           output |= MOUSE_DATA << i-1;
        }
      
        return output;
}

---

explanation: DIRDATA is the read/write serial state.

The first for loop sends the first byte of data to the mouse, using the clock for the synchronization.

The second one “composes” the result bit by bit, reading the data that come from the mouse.

Comments? Any questions? Use the “Comments” button :)
THANKS TO TIZIANA (TES T) FOR HELPING ME WITH EVERY ITALIAN-ENGLISH TRANSLATION!

ZIPPED SOURCE FILE