Rotary Encoder on Arduino prototype shield

Rotary Encoders can offer high precision, long life and a simpler/digital interface over analogue devices, such as potentiometers, for reading a rotational movement on a computer. They’re often fairly expensive, but I recently picked up a bargain pack on eBay and Mouser also have a selection for around a dollar.

There are a number of interface and encoding techniques used by encoders, ranging from devices that provide a digital output of the angle of the shaft – with resolutions ranging from 8 to over 8000 counts per revolution, to simple 2 bit incremental encoders which report clockwise or counterclockwise movement of the shaft, this article looks at decoding the latter.

The rotary encoder indicates movement by toggling the output of two pins from high to low or vice-versa, the direction of rotation is indicated by which line goes high (or low first) as shown in the following diagram from wikipedia:

The waveform produced from the encoder I tested with when rotating clockwise then counter clockwise is shown below:

Decoding the Encoder
There are many ways of decoding the changes in pin logic level to direction of rotation, but I think the following is the simplest. If you look at the waveforms above, a clear pattern emerges: travel from left to right over the waveform above (simulating rotation the shaft in one direction), when the inputs are the same (both high or both low) the last input to have changed will be A, if the inputs are different then the last input to have changed will be B. If the shaft is rotated in the reverse direction (travelling from right to left over the waveform) the opposite is true. If we write these conditions in binary expressions: A is equal to B, last changed pin is A, direction is left we can create a truth table:

From this we see that the we can use a simple XOR to calculate the direction of travel (direction == left) = (A == B) ^ (changedPin == A)

Note, that the above generates 4 rotation signals on each complete quadrature rotation – with some encoders this is too high a resolution (the mechanical ones I’ve tested this with are ’stepped’ – they click as the shaft is turned, resting with with both pins at zero). So it may be better to just record movement when both pins pins have fallen to the low state (A == 0 && B == 0) and ignore other changes.

Detecting Pin Changes
The two pins from the rotary encoder are attached to digital IO pins on the microcontroller and held to ground with a resistor until rotation causes them to be go high. Rather than polling for changes, interrupts are used to trigger execution of a handler function every time the line state changes. This allows for other operations to be done whilst waiting for input.

In this example AVR external pin change interrupts are used. These can be used to detect changes on nearly all of the devices IO pins. PCINT18 and PCINT19 are used below, these are triggered by changes to the AVR IO pins PD2 and PD3 – Arduino pins D2 and D3 respectively, see here for a mapping. Pin change interrupts are handled in 3 groups, PCINT0..7, PCINT8..14, PCINT16…23 and are controlled by the PCICR and PCMSK0-PCMS2 registers, we’re using pins in the same group to simplify setup. Note that we have to use the same interrupt handler to receive events for both pins, the pin value is queried to see which has changed:

Debouncing
The mechanical encoder I tested with create multiple triggers on a single transition due to bouncing. The encoders datasheet claims a maximum bounce of 5ms, but I didn’t see more than 1ms. The waveform below shows a very much worse case of a pin transitioning from high to low.

This is simply debounced in software by waiting for 1ms and then reading the pin values – if neither has changed from the stored value we ignore the trigger. Note, that this technique will fail if the shaft is being rotated to fast and the width of the cycle approaches 1ms or the two signals are less than 1ms apart.

The previous values are stored in a two value byte array and we refer to pins A and B as 0 and 1 in the code to simplify things. The Rotary Encoder decode logic is the simple boolean expression ((pinValues[0] == pinValues[1]) ^ changedPin) which returns true or false to indicate clockwise or counter clockwise shaft rotation. This is used to increment or decrement an integer counter, which the main loop prints back to the host computer.

Conclusions
This is a fairly simple technique that works well for slow rotations of the shaft, but fast rotations of the shaft get lost or be reported in the wrong direction – good for replacing potentiometers as instrumentation dials but not for recording the exact movement of a motor etc.

Full source is here.

References/Bibliography

Related posts:

1. Using SPI on an AVR (2)
2. Using SPI on an AVR (3)
3. Using the MAX6675 Thermocouple-to-Digital Converter

My Apple Time Capsule runs hot – approaching 50°C to the touch – this isn’t helped by the lack of space it has and the Apple TV stacked on top (I’ve added some legs to give some space below and above for air to flow. On large backups/restores during the summer – the device often went into over heat warning mode. There’s also worrying reports of the power supply overheating and Time Capsules dying.

I originally thought of a standard PC fan with some kind of thermistor /thermocouple/sensor and a simple control circuit to activate the fan when temperature gets too hot, but stumbled across Arctic Cooling Pro TC F9 fan which has a temperature sensor on a 40cm cable to turn up the fan speed when the temperature rises above 32°C.

Replacing the plug with a 2.1mm power jack to fit a 12V wall wart PSU and creating a stand with a loop of wire coat hanger sleeved in heat shrink to give it a nice black cover to match the fans case and the unit was ready to go. Taping the end of the temperature sensor to the top of what felt the hottest part of the Time Capsule (over the power supply next to the power inlet) reduced the temperature to less than 30°C. I though the fan might be too low powered initially but it manages to cool all the devices on the shelf it’s on.

The unit is silent – at least quieter than the ambient noise and hopefully will extend the life of the Time Capsule.

References/Bibliography

1. Arctic Cooling Pro TC F9 fan
2. The Apple Time Capsule Memorial Register
3. Guardian: What’s killing Apple’s Time Capsules after 18 months?

Related posts:

1. SMT Table Top Reflow Oven (part 1)
2. SMT Table Top Reflow Oven (part 2): Controlling the Heater Elements
3. 5V-3.3V bidirectional level converter

The circuitry below involves mains electricity, don’t try this unless you are sure you know what you are doing – check, test and insulate repeatedly and thoroughly. There are a number of commercial relay control boards available, for example Futurlec and Elector.

The Hinari HTP033 oven has two elements and a total power rating of 630W – so each draws just over 1.3A at 240V (UK mains voltage), this obviously can’t be provided directly from a microcontroller IO pin but requires some kind of relay. There’s a huge range of relays available – I choose a IMO SRRHN-1C-S-5VDC, this can operate at 5Volts, draws 100mA (I actually found it took under 75mA) and is fairly cheap (a few £). Although a 5V device can be driven from a microcontroller IO pin, 100mA is too high a load, 40mA is the maximum for most AVR Microcontroller IO pins, although the maximum current drain for the entire device is around 200mA, so 40mA can only be driven on a few IO pins at once.

Driving the relay
A simple transistor/resistor circuit can be used to control the relay with much lower power drain. Basically the transistor (I used a 2N2222A) is being used as a current amplifying switch. When the transistor is being used in on/off mode – only approximate mental/back of the envelope maths are needed to calculate the values of the resistors (Search Google for more background).

From the transistors datasheet, when the 100mA of current required to power the relay flows from collector to emittor the transistor will provide a minimum gain of just under 100 – so atleast 1mA needs to flow into the transistors base, if the IO pin is high at 5V and there’s a 1V voltage drop from the transistors base to emitter, a resistor of 4K will provide this (R = V/I = (5V-1V)/1mA). To cope with less gain and a lower Vbe voltage, it’s best to provide much more current to I used a 1330R and measured 3.5mA going into the base of the transistor when on.

Resistor R2 connects the base to ground when the input is unconnected. This ensures the relay will be safely turned off during microcontroller startup. The 10K resistor ensures the current flowing through it when the input is high will be low.

The relay is just a coil of wire which acts as an electromagnet when current flows through it, unfortunately when the power is switched off it will act as an inductor pumping current back into the circuit – the diode protects the transistor when this happens by providing a ‘return path’ to the 5V supply.

Installation
The circuit (2 of them) was simple enough to build on a Prototype/Vero board (pictured above) and housed in a plastic box to protect from earthing. I bypassed the ovens element and timer controls and passed the live mains wire to the relay box with an output to each of the elements.

Some brief tests with an Arduino turning on the relay control pins showed that the relevant oven element came on perfectly, with a reasuring click from the relay as it switched.
Now I have more control over the ovens elements the plan is to do more extensive testing to see how controllable the temperature is.

References/Bibliography

1. IMO SRRHN-1C-S-5VDC
2. Google Search: Using transistor as a power switch

3. 2N2222A transistor datasheet
4. Commercial Relay boards: Futurlec andElector.
5. Some other relay control articles on the web SparkFun

Related posts:

1. SMT Table Top Reflow Oven (part 1)
2. First Arduino Project: the finger
3. Xyloduino: Simple Arduino/piezo organ

AVR SPI Slave Mode
When a device is operating as the SPI slave device it receives data under control of the master:

1. The slave devices slave select (SS) pin is brought low by the master.
2. The master oscillates the SCK clock as it places bits onto the MOSI line and reads from the MISO line.
3. It’s the master’s responsibility to use the SPI mode the slave is expecting (whether data is written and read on the rising or falling edges of the clock) and to make sure the clock rate is not too high for the slave.

The AVR’s built in SPI hardware takes care of receiving and processing the SPI data and placing the received data a byte at a time onto the SPI data register buffer, the program simply needs to consume the read bytes from the buffer fast enough.

There are two ways for the program to ascertain when data is ready, it can either poll the SPI status register to see when a byte has been received (SPSR = (1<<SPIF)) – the same send_spi() helper function that was developed in a previous article can be used.
Alternatively the SPI system can be configured to generate an interrupt when a byte has been received and is ready to read from the buffer. This is achieved by setting the SPIE bit in the SPI control register (SPCR = (1<<SPIE)), I encapsulated this as a parameter to the spi setup helper function developed earlier.

Example
To reduce the amount of code to be written, each program (the AVR GCC and Arduino) acts as both master and slave, and either part can be replaced with the other (ie. two Arduinos can be used etc.). The circuit is shown below, apart from the SPI connections each device has an LED and a push button connected.

When the push button on one device is pressed, the LED on the other flashes. This is achieved using the following logic:

1. The device is put into SPI slave mode so that an interrupt is raised when data is received on the SPI bus.
2. When the button is pressed the program puts the AVR into SPI master mode and sends the slave a message (a number of bytes) then goes back into slave mode.
3. The program’s SPI interrupt handler simply stores the bytes received in a buffer until a terminating null byte (0×00) is received, it then parses and processes the message.
4. Currently a single message type is supported – FLASH_LED (0×00) which is followed by a byte containing the number of times the slave should flash its LED – so to make the slave flash its LED 5 times the master would send 3 bytes – 0×01, 0×05, 0×00.

With the SPI system in slave mode and with interrupts enabled the interupt service handler for SPI_STC_Vect will be called when a byte has been received. All the handler implementation does (below) is save the byte received from SPI in a buffer (incoming) and checks if the byte received is null or we’ve filled the buffer, if so the parse_message() is called to process the data received. As stated previously the interrupt handler mu st return fast enough to handle the next received byte. Whilst the handler is running interrupts will be disabled and if it takes too long data will be lost.

The received_from_spi() function simply reads the byte read from the SPI pipeline and sets the value of the next byte to be sent – note the SPDR buffer is double buffered so the value can be written before being read.

Using an interrupt handler to receive and process the SPI data allows the AVR to perform other tasks, or sleep, until all data is ready.

Sending a SPI message on button press
We also use an interrupt to trigger sending of a message when a button is pressed in the SPI master. We configure the AVR to trigger an interrupt when a pin goes low due to the button being pressed. The Arduino has a helper function to set this up:

This will result in the function “button_pressed” being called when external interrupt 0 (Connected to Arduino pin D2) goes from high to low (FALLING). In native AVR GCC this takes a little more effort – we set the relevant bits in the EICRB register to receive an interrupt on a falling signal (ISCO1 and ISC00), enable external interrupts in EIMSK register, and then enable interrupts (sei()). See the External Interrupt Channel of the relevant AVR datasheet for details of the registers.

The above configuration results in the handler named ISR(INT0_vect) being called when the INT0 pin goes from high to low, both this and the Arduino’s button_pressed() just call the send_message function to transmit a message. This attempts to put the device into SPI master mode, checks that it was successful (If its select pin isn’t low) and if so selects the other device, sends 3 bytes, then deselects the other device and goes back into slave mode:

The AVR spec says the SPI clock frequency in the slave device shouldn’t exceed the MCU frequency/4 – I’ve found frequency/8 is safer.

We’ve seen that the slave device just stores byte received until it receives the terminating null byte, it then calls parse_message(). This checks the value of the first byte in the buffer and parses the remaining bytes accordingly. The current implementation just supports the single FLASH_LED_COMMAND which reads the next byte and flashes an LED that number of times. If we receive an unexpected message the LED is flashed repeatedly:

The complete programs are shown below and are also included as examples in the SPI helper library zip below
AVR GCC:

Arduino:

References

• AVI SPI library
• Serial Peripheral Interface
• AVR AT90USB82/162 Datasheet
• AVR ATmega48/88/168/328 Datasheet
• AVR151: Setup And Use of The SPI

Related posts:

1. Using SPI on an AVR (2)
2. Using SPI on an AVR (1)
3. Using the MAX6675 Thermocouple-to-Digital Converter

Maxim’s MAX6675 8-pin SOIC chip is a compact and simple to use solution for converting the output of a type K thermocouple to a digital temperature value read over SPI. It provides Digital to Analogue conversion of the voltage produced by the thermocouple, cold-junction compensation, noise reduction and processing of the result into a binary temperature value at a precision of 0.25°C.

SO - MISO (Arduino D12), SCK (Arduino D13), CS (Arduino D8)

The thermocouple is connected to pins 2 and 3 – if connected the wrong way around the temperature output from the MAX6675 will go down as the end of the thermocouple is heated. Connecting the MAX6675 to the Arduino is straightforward – just power and the SPI MISO and SCK (clock) and chip select line (^CS). Pin D8 was used to select the device.

SPI Setup
From the datasheet we see that the MAX6675 transmits the temperature in 2 bytes – most significant bit first. The clock is expected to be idle low and data can be read when it is falling (SPI mode 1). The MAX6675 can take a maximum SPI clock rate of 4.3MHz – as the Arduino was running at 16MHz a SPI data rate of Clock/8 (2MHz) was specified so the device was operating well within its tolerances.
The following sets up up the MAX6675 chip select pin (Arduino Pin D8) control pin, SPI and the Arduino Serial line:

Reading the Temperature
Reading the temperature value is equally straightforward. Select the device, wait atleast 100ns (this is close to the time that it will take the AVR to start sending data on the SPI bus anyway but I put in a microsecond delay to be certain), read the two bytes from SPI, and deselect the device.

The 16-bits read from the device in two bytes need to be processed slightly:

Bit 2 in the 2nd byte will be high if the device cannot detect an attached thermocouple, otherwise the 12 temperature value bits spread across the 2 bytes (6-0 of the hight byte, and 7-3 of the low byte) need to be shifted into a single numeric value (highByte << 5 | lowByte>>3).

The program simply prints the bytes received on an error and the temperature (divided by 4 to get the value in degrees) if it has been read successfully.

The MAX6675 has a maximum conversion time of 0.22 seconds. If the device is sampled faster than this it will continue to output the temperature that was first read without any indication that it is being read too fast – I found a delay of atleast 250ms between readings the device worked well.

The complete sampling code is shown below:

Conclusions
Compared with manual reading and conversion of the thermocouple voltage to temperature the MAX6675 is a delight to use. Although it is not a cheap device it is comparable to other thermocouple processing devices (for example the AC1226 and LTK001) but is fairly unique in having a digital/SPI output rather than a cleaned up voltage per Centigrade value that also requires a D/A converter.

References/Resources

1. AVR SPI Helper Library
2. MAX6675 Spec sheet
3. Break out board PCB

Related posts:

1. Using SPI on an AVR (3)
2. Using SPI on an AVR (2)
3. Using SPI on an AVR (1)

The Level converter PCB has finally arrived from BatchPCB. Their service was easy to use and took about 4 weeks to arrive (as advertised).

Because the board was less than the minimum 1″ square they had already doubled it up so I got 2 for $2.50 + $1.20 postage (untracked and uninsured) and $10 handling. With this size the service obviously dwarfs the PCB cost so its worth batching up your order to reduce the overhead. I had ordered two of the level converter board and another very small SOIC-8 break out board and received 8 pieces for $21.20.

I was keen to use this to test SMT soldering in my converted mini oven. Adding paste using a syringe was much harder than anticipated. The paste was fairly thick and left thin tails which required cleaning up.
Despite dozens of tests with the temperature gauge on the oven, half way through the process it stopped working so I had to play it by ear – I turned the oven off just after the solder went molten and reflowed around the components (a magical sight). I might have left it a little late as the PCB has a slight brown tint to it.

The excess solder that hadn’t been cleaned off the board had formed small balls which could be chipped off as can be seen below. The pads which had too much paste formed balls around the pins of the chip. Otherwise the solder flowed around the components surprisingly well.

I had made two screw ups with the PCB layout: first the the labels are too small to read, secondly more serious I mixed up the pin layout on the MCP1700 LDO, which resulted in it burning out when connected to 5V – luckily without harming any other components.

It was just about possible to replace the burnt out component with a T0-92 version soldered to the capacitor pads. This worked fine and the power shift and logic level converter worked as expected. I need to test the max amount of current that the LDO 5V-3.3V downshifter can provide without getting too hot (the T0-92 package is likely to be better than the SOT-23 anyway).

TI TXS0104E and family
Another option in level conversion is the Texas Instruments TXS0104E and family these are available in 2-8 bit conversion packages in both open-drain and push pull versions. These chips also have a output enable pin which can be used to pu the I/O pins into tri-state mode which could be useful.

Related posts:

1. 5V-3.3V bidirectional level converter
2. SMT Table Top Reflow Oven (part 1)
3. Using the MAX6675 Thermocouple-to-Digital Converter

My soldering iron is dirt cheap, low power and pretty poor for soldering SMT components. After looking at the price of a more suitable replacement I decided that it was worth looking at the option of making an SMT Reflow oven from a mini/toaster oven, it would cost less than a decent temperature controlled iron and be fun to create.

The Oven
I seem to be suffering from several of the symptoms of lead poisoning already, so use lead-free solder and want to continue, which means a higher temperature is required.

Googling for lead-free solder reflow temperature profiles gives lots of results from both solder and parts manufacturers (Altera, Wolfson Micro, Lattice Semiconductor, and Kester), and the ’standard’: IPC/JEDEC J-STD-020D.1. These suggest that a max temperature of between 235-255°C is required and the ability to ramp up the temperature towards the max to reduce the time at the high temperatures (30 seconds within 5% of the max).

This is tough for a mini oven, many are advertised with a maximum of 220°C. However, some experiments recording the temperature of my parents cheap Hinari Tiny Top with a thermocouple attached to a multimeter, showed that it could get up to over 255°C (the ovens thermostat seems to cut out at around 260°C – less than the rated 280°C) despite only using 630 Watts. The only caveat is that as it approached the maximum it could only raise the temperatures by about 0.5-1.0°C/Second. However, the oven was also loosing a lot of heat, particularly from the top, so some insulation may help things.

I considered some of the more powerful ovens (1300-2500W), in particular one with a fan would have been good to regulate the temperature around the oven, but they have correspondingly larger spaces to heat – 10-24 litres – compared with the smaller 6.5 litres. I decided to go with a Hinari HTP033:

1. It has two heating elements which allows for more slightly more fine grained temperature control (rather than on/off of a single element)
2. Has a transparent door allowing the reflow process to be monitored
3. The housing looks easily to insulate and modifiable
4. £20 delivered from ebay (Amazon were out of stock)

The Plan

1. Insulate Mini Oven.
2. Thermocouple to monitor temperature.
3. Microcontroller monitoring the temperature and controlling the heater elements.
4. USB interface for control/uploading and downloading temperature profiles.

As stated above – if the ovens heating elements aren’t quick enough, then using a microcontroller to control the temperature is redundant overkill. Its just enough to turn on the oven, put the board in when the temperature gets high enough, then turn off and open the door when the maximum temperature is achieved. If this was the case the backup plan was to just add an LCD screen showing the current temperature and use the oven manually.

Thermocouple
I thought that measuring the temperature would be simply a matter of connecting a thermocouple (which creates a voltage difference based on the temperature difference between the two metals in its probe) to an Analogue to Digital Converter in some configuration and reading off the temperature value, but it appears to be a fairly non trivial task. Luckily there are a number of off the shelf integrated circuits that the thermocouple can be connected to directly and produce a digital temperature reading. I choose the MAX6675, which provides 0.25°C resolution from 0-1023°C on a simple to use SPI output in an 8 pin SOIC.

Testing
To get temperatures from the oven a Teensy at90usb162 board was used to poll the temperature every second and send it to the USB, where it was copied into a spreadsheet.

Chart below shows two test runs of the oven with both elements on (I turned off the oven earlier on the second run).

Surprisingly it got up to to well over 300°C, before I cut the power, with no sign of a thermostat limiter. The temperature rises at roughly 0.9°C a second to 200°C then slows down to about 0.5°C/Sec. to 250°C. Although the slow down towards the peak is disappointing – this is probably just about usable although it would be better to reduce the time spent near the maximum.
The amount of heat escaping from the oven is fairly excessive – the temperature of the top of the oven was approaching 100°C so some insulation will help to increase the gradient.

Insulation
After some research I chose to use Reflect-A-Gold sheet for insulation, this aerospace/automotive heat insulation isn’t the cheapest available but was fairly easy to use and claims to reflect 80% of radiant heat up to 850°F.

The HTP033 is made of riveted sheet metal with a slightly thicker back plate to keep it rigid, after drilling out 4 rivets the oven basically falls apart. The side and top comes away from the internals of the oven allowing it to be just about completely wrapped with the Reflect-A-Gold sheet. Most of the oven had two layers of sheet, with several layers around the edges of the door to increase the closeness of the fit (without there was a 5mm gap with the door closed).

Results after insulation are are shown below, the oven was turned off as close as possible to 245 °Centigrade.

After insulation the oven temperature increases by about 1°C/S. to 200°C and 0.75°C/S. after that (Compared with 0.9°C/S. and 0.5°C/S. respectively for the uninsulated oven). Temperature inside the case behind the ovens controls went up to about 50-60 °C – perhaps still a little too hot to house the electronics.

Conclusions and Future Work
I’m fairly happy with the performance of the oven, considering its cost and size. Next steps are:

1. More temperature tests to see if the performance can be increased.
2. Do some test ‘reflows’ – just turning on the oven and turning off when it reaches the maximum temperature to see what temperature is required by the solder and how good the results are.
3. Develop a controller/relay board and investigate controlling the heating elements under processor control.

References/Resources

1. Other projects: “Toaster oven SMD”, “SMD ReflowToaster Oven”, “Easy Reflow”, “Have you seen my new soldering Iron?”, “Reflow Skillet”. And products: “techFX reflow 2.0 controller with PID control!”, “Artic Reflow Oven”, “GF C2 Reflow Oven”.
2. Various reflow temperature profiles: Wolfson Micro, Lattice Semiconductor, and Kester R206 Solder Paste.
3. IPC/JEDEC J-STD-020D.1 Moisture/Reflow Sensitivity Classification for Nonhermetic Solid State Surface Mount Devices
4. Taking the Pain Out of Pb-free Reflow, Lead Free Magazine
5. MAX6675 K-type Thermocouple-to-Digital Converter
6. Reflect-A-Gold Heat insulation sheet and tape

Related posts:

1. SMT Table Top Reflow Oven (part 2): Controlling the Heater Elements
2. External Time Capsule Fan
3. Using the MAX6675 Thermocouple-to-Digital Converter

Maxim DS1305 Real Time Clock
The DS1305 Serial Alarm Real-Time Clock is an 18 pin DIP clock chip. When setup with a 32.768kHz crystal and optional backup battery, it provides a real time clock, 2 programmable alarms that drive I/O pins (which can be used to trigger interrupts on the MCU), 96 bytes of RAM and a rechargeable battery charger accessible from SPI or 3-wire interconnect.

The datasheet contains a simple circuit, without a battery attached V_CC2 and V_BAT should be connected to ground and V_CC1 and V_CCIF to 5V, for SPI operation SERMODE pin should be connected to 5V, then SDO is MISO, SDI is MOSI, SCK clock, and CE chip enable.

SPI Configuration
From the datasheet we read that the device samples the state of the clock when the chip enable pin goes high to decide whether the SPI master is using a high or low idle clock level allowing either CPOL of 0 or 1 to be used. Data is sampled on the trailing edge of the clock (CPHA=1) so SPI mode 1 or 3 can be used. Data is read and written MSB first. Unlike some SPI devices the chip select pin is driven high to select the chip.

All DS1305 functionality is accessed through 127 byte-wide data registers. All registers have one address for reading (0×00-0×7F) and one for writing (0×80-0xFF) as shown in Figure 2 of the datasheet and copied below:

Using the DS1305
The register structure of the DS1305 makes the communication protocol to the device very simple. The MCU transfers a byte containing the address of the data to be read or written. If writing to a register it then writes the byte to MOSI and ignores the data on MISO, if reading it writes a dummy byte to MOSI and reads the register value from MISO. The DS1305 SPI Slave uses the address transferred in the first byte to determine whether to ‘read’ or ‘write’ the next byte.

The device also supports burst mode – if the chip select is kept high after a read or write, further data can be sent or received with an implicit address increment. So the current date/time can be sent in a stream of bytes to set the current time.:

Note, that the DS1305 uses Binary Coded Decimal with each decimal digit being represented in 4 binary bits, so 47 in decimal is represented as 0×47 in hex.
When only a single digit is required (for example to represent the most significant digit in the 12 hour clock time (0 or 1) only 1 bit is used.

A simple library of helper functions, macros, and structures simplifies usage further, for example:

After enabling the oscillator and setting the current time, get_time() can be used to fetch the value of the current time, which will increment every second.

The DS1305 also has two programmable alarms which can be configured to trigger either at a specific time of the week, or once every second, minute, or hour. The status register can be polled to see when the alarm has triggered or, more usefully, one of the interrupt lines (INT0 and INT1) can be made to go low when the alarm trigters (by setting the INTCN and AIE0 and AIE1 flags in the control register). The 7th bit of the alarm time registers (second, minute, hour, and day) are used to choose the granularity of the alarm shown on table 1, page 7 of the datasheet and repeated below:

For example, to set alarm 0 to trigger at 10:33:03 every day and bring the INT0 pin low would require:

Invoking an Interrupt on Microcontroller
If the INT0 pin of the DS1305 is connected to a pin on the microcontroller we can initiate an interrupt to execute some code when the alarm triggers.

On the Microcontroller we enable external interrupts on the INT0 pin (which differs across different AVR Microcontrollers) so that when the line goes from high to low.

More details of the options available to set up interrupts (for example whether the interrupt should be triggered on rising or falling edges) is included the “External Interrupts” Chapter in all AVR datasheets.

After configuration, when an interrupt occurs the following Interrupt Service Routine will be called, the code fetches the alarm time to clear the interrupt flag on the DS1305

The example code is included in the SPI helper library below.
Updated 2010/02/24: SPI library code moved to Google Code

References/Resources

1. AVR SPI helper library
2. Serial Peripheral Interface
3. AVR AT90USB82/162 Datasheet
4. AVR ATmega48/88/168/328 Datasheet
5. AVR151: Setup And Use of The SPI
6. DS1305 datasheet

Related posts:

1. Using SPI on an AVR (3)
2. Using SPI on an AVR (1)
3. Decoding a Rotary Encoder

The Serial Peripheral Interface – SPI – allows digital devices to communicate using only 4 wires, additional devices can be added to the same ‘bus’ with the addition of only a single selection wire for each device.

There are many integrated circuits and other devices that can be controlled via SPI, this entry details a simple experiment with a MCP3201 12-bit Analogue to Digital Converter.

Background
Each end of a SPI connection is acting in one of two roles – Master or Slave. The master is responsible for initiating and controlling the communication.

The basic mode of operation is very simple: When the master wishes to initiate transfer of data:

1. It sets the SS (Slave Select – often called CS – chip select) pin low to tell the slave that communication is about to start
2. The master writes a bit of information onto the MOSI (Master Out Slave In) wire (sets it to 0 or 1) and the slave does the same on the MISO wire (either of these can be omitted if the data transfer is one way)
3. As the master ticks the clock line SCLK it will read the value of MISO (Master In Slave Out) wire (which the Slave has written) and the slave will read the value of the MOSI wire (whether the data is sampled as the clock rises or falls depends on which mode is in operation)
4. The process is repeated from (b), transferring a bit of data on each pulse of the clock until all data is transferred

The above can be implemented in software using normal I/O pins but nearly all AVR microcontrollers have hardware support, thus to transfer a byte is simply a matter of doing:

In master mode any I/O pin on the MCU can be used as chip select to tell the slave that it is being selected. In slave mode the SS pin will be lowered to indicate that this device is being selected.
The I/O pins used for SPI vary across the AVR family, for example the pins for the AT90/ATmega/ATtiny are shown below along with the Arduino mappings.

Setup
Although the pins may be different, setup is fairly consistent across all (as well as the spec sheets for individual MCUs AVR SPI support is described in AVR151: Setup And Use of The SPI)

SPI is configured using by setting the SPI Control Register (SPCR) with the following bits:

• Enable – (SPE) – 1 to enable SPI
• Master/Slave – (MSTR) – whether the MCU is acting as a master or slave.
• Clock Divisor – (SPR0, SPR1, SPXI2 in SPSR) indicates the frequency of the clock, represented as a divisor of the MCU clock
• SPI timing mode (CPOL, CPHA) – controls if data is output to the MISO and read on the rising or falling edge of SCK
• Data Order – (DORD) – whether the MCU is acting as a master or slave.
• Enable Interrupt (SPIE) – whether an interrupt should be raised on successful transfer of data.

To simplify setup I created a basic helper library (currently just for master mode) with a setup function that takes a timing mode, data order, interrupt, and master clock/slave spec arguments, and #defines for the values – spi.h, spi.c.

Following shows some simple SPI interaction with the MCU acting as master with a simple device.

SPI to a 12 bit A/D convertor
The picture below shows a Microchip Technology MCP3201 12 Analogue to Digital converter connected to the SPI pins of an MCU. Although most AVRs have an ADC (the AT90USB162 doesn’t)- the MCP3201 offers higher precision than the 10-bits in most.

Control of the MCP3201 D/A converter is fairly straightforward and detailed in the (datasheet. When the microcontroller sets the ^CS pin to low the chip samples the input to IN+ (a potentiometer provides the input in the circuit above) sends the digital representation on D_out line as the CLK line is pulsed by the master. The MCP3201 is a read only device MOSI is not used.

From the datasheet we see the clock frequency can be a max of 1.6MHz at 5V – using a divider of 16 (assuming 16MHz Microcontroller clock) for SPI will give us a safe 1MHz clock frequency. The device is agnostic about whether operating with leading or trailing clock (can be used in any SPI timing mode).
The only tricky part is that the 12 bits will be delivered in 2 bytes (most significant bit first), which will have to be recomposed into a single value – see figure 6.1 of the datasheet. The following samples the value and displays the value of the top 3 bits by lighting one of the 8 LEDs on the port B.

Updated 2010/02/24: SPI library code moved to Google Code

References

• AVR SPI Helper Library
• Serial Peripheral Interface
• AVR AT90USB82/162 Datasheet
• AVR ATmega48/88/168/328 Datasheet
• AVR151: Setup And Use of The SPI

Related posts:

1. Using SPI on an AVR (3)
2. Using SPI on an AVR (2)
3. Using the MAX6675 Thermocouple-to-Digital Converter