Interfacing a DS1390/DS1391 RTC with a Motorola DSP with SPI

Abstract: This app note shows how to connect a DS1390 to a Motorola DSP that has a built-in SPI™ interface module. This circuit uses the Motorola DSP56F800DEMO Demonstration Board and CodeWarrior® IDE.


The DS1390 Real-Time Clock (RTC) may be interfaced with a microcontroller (µC) or Digital Signal Processing (DSP) unit using a SPI interface. This app note shows how to connect a DS1390 to a Motorola DSP that has a built-in SPI interface module. This circuit uses the Motorola DSP56F800DEMO Demonstration Board and CodeWarrior IDE.

Using the Example Software

The example software was developed by starting with a blank project. Follow the instructions in the Motorola Kit Installation Guide (Tutorial: Creating a CodeWarrior Project) for details. Add the code included in this application note in main.c.


The program uses a GPIO port to control CS on the DS1390. The software initializes the SPI controller module and the DSP writes the time and date to the DS1390. The software then loops reading the time and date. The DS1390 and DS1391 support SPI modes 1and 3.

A schematic of the circuit is shown in Figure 1. This circuit comprises a daughter card that is attached to the Motorola demo board. Please note that the circuit in Figure 1 includes several RTCs with SPI interfaces. Only one RTC may be used at a time, and the software only supports the DS1390. The software is shown in Figure 2.

Figure 1.
Figure 1.

Figure 2. Schematic of daughter card.
More detailed image
(PDF, 138kB)
Figure 2. Schematic of daughter card.

Figure 3. Code Listing

/* File: DS1390.c */
/* This example program was developed using the Motorola
56F800 Demo Board Kit.  Follow the kit instalation guide
for creating a CodeWarrior Project.  Use the shell of the
new project for this example.  Note: This program is for
example only and is not supported by Dallas Semiconductor
Maxim. */

#include "port.h"
#include "stdio.h"
#include "stdlib.h"

* Main program for use with Embedded SDK

extern sampleASM (void);

void reset_spi(void);
void wbyte_spi(unsigned char);
void init_sci0(Word16);
tx_sci0(unsigned char);
void bcd2ascii(unsigned char);
unsigned char  rbyte_spi(void);

#define REG_BASE 0x0000
#define SCI0_BASE 0x0F00
#define SPI_BASE 0x0F20
#define GPIOA_BASE 0x0FB0
#define GPIOB_BASE 0x0FC0

#define SCI0_SCIBR *(volatile UWord16 *)(SCI0_BASE + 0)
#define SCI0_SCICR *(volatile UWord16 *)(SCI0_BASE + 1)
#define SCI0_SCISR *(volatile UWord16 *)(SCI0_BASE + 2)
#define SCI0_SCIDR *(volatile UWord16 *)(SCI0_BASE + 3)

#define SPSCR *(volatile UWord16 *)(SPI_BASE + 0)
#define SPDSR *(volatile UWord16 *)(SPI_BASE + 1)
#define SPDRR *(volatile UWord16 *)(SPI_BASE + 2)
#define SPDTR *(volatile UWord16 *)(SPI_BASE + 3)

#define GPIO_A_PUR *(volatile UWord16 *)(GPIOA_BASE + 0)
#define GPIO_A_DR *(volatile UWord16 *)(GPIOA_BASE + 1)
#define GPIO_A_DDR *(volatile UWord16 *)(GPIOA_BASE + 2)
#define GPIO_A_PER *(volatile UWord16 *)(GPIOA_BASE + 3)

#define GPIO_B_PUR *(volatile UWord16 *)(GPIOB_BASE + 0)
#define GPIO_B_DR *(volatile UWord16 *)(GPIOB_BASE + 1)
#define GPIO_B_DDR *(volatile UWord16 *)(GPIOB_BASE + 2)
#define GPIO_B_PER *(volatile UWord16 *)(GPIOB_BASE + 3)

void main (void)
unsigned char   msec=0, min=0x26, sec=0x00, hr=0x17, dow=0x06,
                                date=0x26, mon=0x12, yr=0x03, write = 0;

        init_sci0(195);                 // 30MHz / 195 = 9600 baud

        GPIO_B_DR = 0x0008;             // disable RTC - CS high

        GPIO_B_DR = 0;                  // enable RTC - CS low
        wbyte_spi(0x8d);                // control register write address
        rbyte_spi();                    // dummy read
        wbyte_spi(0x18);                // enable osc, 32kHz sqw
        GPIO_B_DR = 0x0008;             // disable RTC - CS high

                GPIO_B_DR = 0;                  // enable RTC - CS low
                wbyte_spi(0x80);                // select seconds register write address
                rbyte_spi();                    // dummy read
                wbyte_spi(msec);                // milliseconds register data
                wbyte_spi(sec);                 // seconds register data
                wbyte_spi(min);                 // minutes register
                wbyte_spi(hr);                  // hours register
                wbyte_spi(dow);                 // day of week register
                wbyte_spi(date);                // date register
                wbyte_spi(mon);                 // month register
                wbyte_spi(yr);                  // year register
                GPIO_B_DR = 0x0008;             // disable RTC - CS high
                GPIO_B_DR = 0u;                 // enable RTC - CS low

                wbyte_spi(0);                   // seconds register read address
                rbyte_spi();                    // dummy read
                msec = rbyte_spi();             // read milliseconds register
                sec = rbyte_spi();              // read seconds register
                min = rbyte_spi();              // ditto minutes
                hr = rbyte_spi();               // and so on
                dow = rbyte_spi();
                date = rbyte_spi();
                mon = rbyte_spi();
                yr = rbyte_spi();

                GPIO_B_DR = 0x0008;             // disable RTC - CS high

                tx_sci0(0x0d);                  // sequence to print time & date
                tx_sci0(' ');


//15 14  13   12     11   10    9     8    7       6       5    4        3    2    1    0
// r MSB SPRF ERRIE  ovrf modf spte modfen spr1   spr0   sprie spmstr   cpol cpha spe  spite

void reset_spi()
int     val;
        SPSCR = 0x0056; // SPR0, SPMSTR, CPHA, SPE
        SPDSR = 0x0007; // 8-bit size

        SPSCR &= 0xfffd;        // clear spe, resets SPI (partial)
        SPSCR |= 0x0002;        // set spe, new values take effect

        GPIO_B_PER = 0x00f3;    // use GPIOB3 as CS for RTC
        GPIO_B_DDR = 0x000d;    // direction is output

        GPIO_A_PER = 0x00f9;    // enable/disable per function (1=enable)
        GPIO_A_DDR = 0x0006;    // direction is output (1=output)
        GPIO_A_DR  = 0;                 // write bits low (0=low)

void  wbyte_spi( unsigned char  wbyte)  // ------ write one byte -------
        while (!(SPSCR & 0x0200));  // wait for transmitter empty flag

        SPDTR = wbyte;

void    bcd2ascii(unsigned char dat)    // ----- convert bcd to ascii and send to sci ----
        tx_sci0( (dat >> 4) + 0x30);
        tx_sci0( (dat & 0x0f) + 0x30);
unsigned char rbyte_spi(void)   // -------- read one byte ----------
        while (!(SPSCR & 0x2000));  // wait for receiver full flag



void    init_sci0(Word16 baud)
        GPIO_B_PER = 0x00f3;    // set up
        GPIO_B_DDR = 0x000d;    // direction is output

        SCI0_SCIBR = baud;              // baud rate
        SCI0_SCICR = 0x2000;    // control reg
tx_sci0(unsigned char val)
UWord16 reg;

        SCI0_SCICR &= 0xfffb;   // turn receiver off
        SCI0_SCICR |= 8;                // turn transmitter on
                reg = SCI0_SCISR;               // clear flag by reading
        }       while( (reg & 0x8000) == 0);    // wait until RDRF is false

        SCI0_SCIDR = (unsigned int) (val);

Next Steps
EE-Mail Subscribe to EE-Mail and receive automatic notice of new documents in your areas of interest.
Download Download, PDF Format
© , Maxim Integrated Products, Inc.
The content on this webpage is protected by copyright laws of the United States and of foreign countries. For requests to copy this content, contact us.
APP 3313:
APPLICATION NOTE 3313,AN3313, AN 3313, APP3313, Appnote3313, Appnote 3313