TriCore AURIX Family. 32-bit AP32263 V

Transcription

1 TriCore AURIX Family 32-bit Using the RTC (Real-Time Clock) on the TC2x5 Application Kit Application Note V Microcontrollers

2 Edition Published by Infineon Technologies AG, Munich, Germany Infineon Technologies AG All Rights Reserved. LEGAL DISCLAIMER THE INFORMATION GIVEN IN THIS APPLICATION NOTE IS GIVEN AS A HINT FOR THE IMPLEMENTATION OF THE INFINEON TECHNOLOGIES COMPONENT ONLY AND SHALL NOT BE REGARDED AS ANY DESCRIPTION OR WARRANTY OF A CERTAIN FUNCTIONALITY, CONDITION OR QUALITY OF THE INFINEON TECHNOLOGIES COMPONENT. THE RECIPIENT OF THIS APPLICATION NOTE MUST VERIFY ANY FUNCTION DESCRIBED HEREIN IN THE REAL APPLICATION. INFINEON TECHNOLOGIES HEREBY DISCLAIMS ANY AND ALL WARRANTIES AND LIABILITIES OF ANY KIND (INCLUDING WITHOUT LIMITATION WARRANTIES OF NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OF ANY THIRD PARTY) WITH RESPECT TO ANY AND ALL INFORMATION GIVEN IN THIS APPLICATION NOTE. Information For further information on technology, delivery terms and conditions and prices, please contact the nearest Infineon Technologies Office ( Warnings Due to technical requirements, components may contain dangerous substances. For information on the types in question, please contact the nearest Infineon Technologies Office. Infineon Technologies components may be used in life-support devices or systems only with the express written approval of Infineon Technologies, if a failure of such components can reasonably be expected to cause the failure of that life-support device or system or to affect the safety or effectiveness of that device or system. Life support devices or systems are intended to be implanted in the human body or to support and/or maintain and sustain and/or protect human life. If they fail, it is reasonable to assume that the health of the user or other persons may be endangered.

3 Trademarks of Infineon Technologies AG AURIX, C166, CanPAK, CIPOS, CIPURSE, EconoPACK, CoolMOS, CoolSET, CORECONTROL, CROSSAVE, DAVE, DI-POL, EasyPIM, EconoBRIDGE, EconoDUAL, EconoPIM, EconoPACK, EiceDRIVER, eupec, FCOS, HITFET, HybridPACK, I²RF, ISOFACE, IsoPACK, MIPAQ, ModSTACK, my-d, NovalithIC, OptiMOS, ORIGA, POWERCODE ; PRIMARION, PrimePACK, PrimeSTACK, PRO-SIL, PROFET, RASIC, ReverSave, SatRIC, SIEGET, SINDRION, SIPMOS, SmartLEWIS, SOLID FLASH, TEMPFET, thinq!, TRENCHSTOP, TriCore. Other Trademarks Advance Design System (ADS) of Agilent Technologies, AMBA, ARM, MULTI-ICE, KEIL, PRIMECELL, REALVIEW, THUMB, µvision of ARM Limited, UK. AUTOSAR is licensed by AUTOSAR development partnership. Bluetooth of Bluetooth SIG Inc. CAT-iq of DECT Forum. COLOSSUS, FirstGPS of Trimble Navigation Ltd. EMV of EMVCo, LLC (Visa Holdings Inc.). EPCOS of Epcos AG. FLEXGO of Microsoft Corporation. FlexRay is licensed by FlexRay Consortium. HYPERTERMINAL of Hilgraeve Incorporated. IEC of Commission Electrotechnique Internationale. IrDA of Infrared Data Association Corporation. ISO of INTERNATIONAL ORGANIZATION FOR STANDARDIZATION. MATLAB of MathWorks, Inc. MAXIM of Maxim Integrated Products, Inc. MICROTEC, NUCLEUS of Mentor Graphics Corporation. MIPI of MIPI Alliance, Inc. MIPS of MIPS Technologies, Inc., USA. murata of MURATA MANUFACTURING CO., MICROWAVE OFFICE (MWO) of Applied Wave Research Inc., OmniVision of OmniVision Technologies, Inc. Openwave Openwave Systems Inc. RED HAT Red Hat, Inc. RFMD RF Micro Devices, Inc. SIRIUS of Sirius Satellite Radio Inc. SOLARIS of Sun Microsystems, Inc. SPANSION of Spansion LLC Ltd. Symbian of Symbian Software Limited. TAIYO YUDEN of Taiyo Yuden Co. TEAKLITE of CEVA, Inc. TEKTRONIX of Tektronix Inc. TOKO of TOKO KABUSHIKI KAISHA TA. UNIX of X/Open Company Limited. VERILOG, PALLADIUM of Cadence Design Systems, Inc. VLYNQ of Texas Instruments Incorporated. VXWORKS, WIND RIVER of WIND RIVER SYSTEMS, INC. ZETEX of Diodes Zetex Limited. Last Trademarks Update Application Note 3 V1.0,

4 Revision History Major changes since previous revision Date Version Changed By Change Description We Listen to Your Comments Is there any information in this document that you feel is wrong, unclear or missing? Your feedback will help us to continuously improve the quality of our documentation. Please send your proposal (including a reference to this document title/number) to: ctdd@infineon.com Application Note 4 V1.0,

5 Table of Contents Revision History... 4 Table of Contents About this document Scope and purpose Intended audience Real-Time Clock (RTC) description Memory Map Inter-Integrated Circuit (I2C) description I2C Module on TC27X devices Implementation (and project example) Wiring Software Initialization Reading the time Convert to Time Structure Using the analog clock example project Application Note 5 V1.0,

6 About this document 1 About this document 1.1 Scope and purpose This document describes how to utilize the Real-Time Clock (RTC) module mounted onto the TC2x5 Application Kit. The TC2x5 is a product in the Infineon TriCore AURIX family of 32-bit microcontrollers. We outline the main features of the RTC, its memory structure and how to access the time/date information. Using I2C (Inter-Integrated Circuit) we explain how to read from and write data to the RTC. Implementation is documented, including how to initialize the I2C module and convert the time/date information into a useable structure. As an example, we describe an analog/digital clock with an automatic wakeup functionality based on clock triggered alarms. 1.2 Intended audience This document is intended for hardware and software engineers who are going to use the AURIX Application Kit as a jump start platform for own projects. Conventions used Hexadecimal numbers are prefixed with 0x. For example; 0x0F Binary numbers are indicated with a subscript B following the number. For example; 00 B Decimal numbers are indicated with a subscript D following the number. For example; 2 D Application Note 6 V1.0,

7 Real-Time Clock (RTC) description 2 Real-Time Clock (RTC) description The Application Kit has a built-in RTC, the MCP7940M by Microchip. The clock manages the hours, minutes, seconds, day of the week, date, month and year. The clock allows two separate alarms to be set. If an alarm condition is met, the RTC drives the multi-purpose pin, and connected microcontrollers are able to react on the alarm. This can be used for automatic startups or to execute functions based on time and/or date. The RTC needs an external khz crystal to operate and time data can be read digitally over I²C. Connection is established over the Serial Data Line (SDA) and Serial Clock Line (SCL) pins on the RTC. 2.1 Memory Map The RTC memory map can be read from and written to. Figure 1 Memory Map Conceptually this memory space can be divided into four different sections: 0x00-0x06: Time and date 0x07-0x09: Configuration and calibration 0x0A - 0x0F: Alarm 0 0x11-0x16: Alarm 1 Application Note 7 V1.0,

8 Real-Time Clock (RTC) description Time and date examples The current time can be read and written from this section. Most of the time components, such as seconds, minutes and hours, are represented in the packed Binary-Coded Decimal (BCD) format. For example the seconds are represented in one, four bit wide (0x00, 0-3) field and another three bit wide (0x00, 4-6) field. The three bit wide field holds the most significant bits in 10 s of seconds and the four bit wide field holds the least significant bits for the seconds. For illustration, two examples are given: 010 B 1001 B 2 D 9 D 29 seconds 101 B 0010 B 6 D 2 D 52 seconds Both bit fields are converted separately into seconds. The three bit wide field is then multiplied by ten and added to the four bit wide field. The other BCD time components are calculated the same way. They differ only in the number of bits of the 10- component. This memory block contains the minutes, hours, day of week, date, month and year, together with a leap year indicator and the field to determine 12 or 24 hour mode. Configuration The register address 0x07 contains the configuration register used to define the RTC functionality. Bits 5:4 define if an alarm is active: 00 B = no alarm 01 B = alarm0 active 10 B = alarm1 active 11 B = both alarms active If the clock is not working as precisely as expected the calibration register (0x08) can be used to add or subtract clocks from the RTC counter every minute. Bit 7 is used to indicate if the clocks should be added or subtracted. The other seven bits can be used to define the clocks to add or subtract. The register value will be multiplied by two, therefore it is possible to decrease or increase the clock speed by 254 clocks per minute. Alarms To set an alarm the register addresses 0x0A 0x0F, 0x11 0x16 are used. They have nearly the same structure as the time/date register block, but with some minor differences: ALMxPOL Defines the level of the MFP pin when an alarm is triggered ALMXIF Interrupt flag if the alarm was triggered, it has to be cleared by software ALMxC These three bits define the alarm match: o o o o o o 000 B Seconds match 001 B Minutes match 010 B Hours match 011 B Matches the current day 100 B Date 111 B Seconds, Minutes, Hour, Day, Date, Month Application Note 8 V1.0,

9 Inter-Integrated Circuit (I2C) description 3 Inter-Integrated Circuit (I2C) description I2C is a multi-master, serial, single-ended computer bus invented to connect low-speed peripherals to an embedded system. The bus requires two bi-directional open-drain lines, Serial Data Line (SDA) and Serial Clock Line (SCL). Each connected device has its own unique 7-bit or 10-bit address. Standard I2C bus speeds are 100kbit/s and 10kbit/s in low-speed mode. Master and Slave nodes Every device connected to the bus is either a Master node or a Slave node. A Master node generates the clock and initiates the communication. Slave nodes respond to the master if they are addressed. The following figure shows the I2C data transfer graphically: Figure 2 I2C Data Transfer Sequence of transmission If a transmission is initiated the master puts the start condition onto the bus. The clock line is kept high, while the data line is changed from high to low. Slave devices read the data while the clock line is high, so the bit is put onto the signal line while the clock is low. The address of the slave device is then written to the SDA line. A Read/Write bit is put onto the bus. If the master wants to read data the Read/Write bit has to be set to 1, else it is set to 0. If the address is valid, the addressed slave device puts an Acknowledge Flag (active low) onto the bus. Now eight bits of data are put onto the bus either by the master or the slave (based on read or write) with every clock cycle. After eight bits either the slave or master sends an Acknowledge bit to indicate a successful transaction. Now the master can either send another message to this slave device by sending another start condition, or end the transmission with the stop condition. To send the stop condition the master keeps the clock high, while changing the data line from low to high. Now the bus is free again and ready for other master nodes to initiate a new transmission with a slave device. Application Note 9 V1.0,

10 Inter-Integrated Circuit (I2C) description 3.1 I2C Module on TC27X devices The TC27x offers an I2C module to simplify the communication with I2C devices. It works in accordance with the I2C-bus specification version 2.1. The module relieves the CPU from many time-critical tasks. Features Master, multi-master and slave mode Different speed ranges (standard, fast and high-speed mode) 7-bit and 10-bit addressing Automatic execution of low-level tasks Flexible clock and timing control TX/RX FIFO buffering Advanced interrupt handling Block diagram The following figure shows the block diagram of the I2C module, with all of its components: Figure 3 Block Diagram of the I2C Module Clock Control, which is derived from the system clock, controls the tact cycles of the I2C kernel and the interface block. A FIFO is used to transfer the data between the CPU and the I2C module during transmission and reception. Six different interrupt requests are available. External hardware is connected via a pair of receive and transmit pins, controlled by the Port Control. Operation The I2C Kernel handles the data transfer based on given configuration values and content of the TX/RX FIFO queues. It handles the complete I2C communication, including start, stop bits, data alignment, data size and timing. The user has to initiate the module with settings based on the hardware configuration (pin selection) and software configuration values (data size, timing, etc.). It is then sufficient to address the slave and put data into the FIFO queue (if used as master). After transmission has ended the received data can be found in the RX FIFO queue. Application Note 10 V1.0,

11 Implementation (and project example) 4 Implementation (and project example) Before we can start the actual coding, we need to know how the RTC module was soldered on the board (4.1). Then we are able to start with the software implementation (4.2). 4.1 Wiring The RTC module is already soldered onto the Application Kit and the following figure shows the corresponding snippet from the Application Kits schematic: Figure 4 RTC Wiring Component U103 is the RTC module. A Hz oscillator is connected to the X1 and X2 pins, as defined in the RTC datasheet. VSS is connected to ground. The VCC pin is connected to the Application Kits standby voltage line. If the board is switched off and a battery is inserted, this line provides current to keep the clock running. The MFP (Multi-Function Pin) can be used either to signal alarms or the clock ticks. It is connected to the /ESR1 pin of the TC27x, an external reset trigger, and also to the boards power regulator (not depicted in this schematic). This setup allows waking up the board from standby with the help of an alarm generated by the RTC module. The last two pins are used for the I2C communication (note the port mapping information, which is important when we have to setup the I2C connection later): SCL is the clock line and connected to the P13.1 pin of the TC27x. P13.1 can be used as input for the I2C0 module as SCL0B (as described in the TC27x datasheet). SDA is the data line and connected to P13.2. Pin 13.2 pin can be used for the I2C0 module as SDA0B. Application Note 11 V1.0,

12 Implementation (and project example) 4.2 Software This section describes how the software for the Application Kit and the RTC module works. First the I2C connection to the RTC module has to be established. After that it is possible to communicate with the module and write / read data. Finally the data provided by the RTC has to be converted and moved into an internal memory structure Initialization The process to setup the I2C for communication with the RTC is divided into the following steps: 1. Load the clock control register The clock control register has to be loaded (line nine of Code Listing 1 - RTC Initialization). Bit 0 of the clock register is used to disable the complete module to save current. Therefore write 0x00 into the register and wait until bit 1 is set to one, which indicates that the module is running. 2. Define the pins We need to set the correct pad driver for the SDA pin which is located on pin P13.2. Which pad driver mode you need to use depends on the peripheral used (refer to the modules datasheet). The pad driver mode is set on line 11 of Code Listing 1 - RTC Initialization. 3. Set the port functionality To configure the two pins P13.1 and P13.2 for I2C set the port functionality (lines 16 and 17). The correct values are to be found in the TC27x datasheet. 4. Configure communication pins The I2C module needs to know which pins are used for communication. This is configured in the GPCTL register. Because this example uses the SDA0B and SCL0B pins, write 0x01 into GPCTL. See the datasheet for other values. 5. Configure the clock rate To configure the clock rate of the I2C module the CLC1 register has to be written. The simplest way is to set it to 0x100, which sets the RMC field to one and leaves the rest of the register on default. With this setting the I2C kernel speed is the same as the controllers baud rate. Wait until the module is successfully loaded, indicated by bit one in the CLC1 register. 6. Kernel configuration Once the peripheral clock, pins and I2C clock have been configured, the main I2C kernel configurations can be performed. FDIVCFG (Fractional Divider Configuration Register): 0x000103B0 This register is used to define the fractional divider for the I2Cs clock rate. The clock rate is derived from the clock rate defined in CLC1. Based on this DEC value and the controllers baud rate the I2C clock runs at 100 khz. For more information about how to calculate the baud rate see the datasheet. ADDRCFG (Address Configuration Register): 0x This register contains the I2C-address (for slave mode) and some basic bits for the general operation of the peripheral. In this case the MnS bit is set to one which defines the I2C module as master. TBAM is set to zero as we don t use the ten bit address mode. FIFOCFG (FIFO Configuration Register): 0x This configuration register is used to set the behavior of the FIFO before communication is started. It contains burst, alignment and flow control settings. In this case RXBS and TXBS are both set to 0x01 meaning that the I2C module can send two words in burst mode. RXFC and TXFC are also set to 0x01 enabling the flow control of the RX and TX FIFO. The alignment setting for TX and RX is set to byte aligned. 7. Start the module Write 0x01 into the RUNCTL register (line 30). The I2C module is now ready and can receive and send data. Application Note 12 V1.0,

13 Implementation (and project example) int32_t rtc_init (void) { } uint16_t index; if (_RTC_running!= RTC_STATUS_UNINITED) return (1); SYSTEM_DisableProtectionExt (0); I2C0_CLC.U = 0x0; while ((I2C0_CLC.U & 0x ) == 2); P13_PDR0.U = 0x00000B00; SYSTEM_EnableProtectionExt (0); // we set the pins here P13_IOCR0.B.PC1 = 0x16; P13_IOCR0.B.PC2 = 0x16; I2C0_GPCTL.U = 0x ; I2C0_CLC1.U = 0x100; while ((I2C0_CLC1.U & 0x ) == 2); // frequency must be less than 400kHz, we use 100kHz I2C0_FDIVCFG.U = 0x000103B0; // we are the master I2C0_ADDRCFG.U = 0x ; I2C0_FIFOCFG.U = 0x ; I2C0_RUNCTRL.U = 0x1; // module run _RTC_running = RTC_STATUS_READY; return (0); // load clock control register // wait until module is enabled // we set our SDA (P13.2) to TTL // SCL0 // SDA0 // use SCL0B/SDA0B // load clock control register // wait until module is enabled Code Listing 1 RTC Initialization Application Note 13 V1.0,

14 4.2.2 Reading the time Using the RTC (Real-Time Clock) on the TC2x5 Application Kit Implementation (and project example) If the I2C module is configured and started, it is possible to send read requests to the RTC (Code Listing 2) int32_t rtc_gettime (TIME *pacttime) { } uint32_t uibytesreceived; uint32_t uidata[2]; I2C0_TPSCTRL.B.TPS = 0x2; I2C0_TXD.U = RTC_I2C_WRITE; I2C0_ICR.U = 0xF; // we wait until MRPS expired and we have the data while (!I2C0_PIRQSS.B.TX_END); // reset the last single request (send byte) I2C0_ICR.U = 0xF; I2C0_PIRQSC.U = I2C0_PIRQSS.U; // send 2 bytes // send 0x6F, write flag and 0 as address I2C0_TPSCTRL.B.TPS = 0x1; // send 1 byte I2C0_MRPSCTRL.B.MRPS = 0x8; // receive 8 bytes I2C0_TXD.U = RTC_I2C_READ; // send 0x6F and write 1 I2C0_ICR.U = 0xF; // reset the last single request // we wait until MRPS expired and we have the data while (!I2C0_PIRQSS.B.TX_END); uibytesreceived = I2C0_RPSSTAT.B.RPS; uidata[0] = I2C0_RXD.U; uidata[1] = I2C0_RXD.U; I2C0_ICR.U = 0xF; I2C0_PIRQSC.U = I2C0_PIRQSS.U; // if we don't read 8 bytes we stop and return an error if (uibytesreceived!= 8) return 1; createdatefromdata(&uidata, pacttime, 0x1); return (0); // we get our received count // we get the first 4 bytes // we get the second 4 bytes // we reset the burst request // we reset the TX_END and RX interrupt Code Listing 2 Read data from the RTC To read data from the RTC module we first need to know its address. In this case the RTC reacts on the 7-bit address B (0x6F). To read a specified address we have to send it to the RTC first. Therefore we need a write operation with two bytes: The first byte contains the address (0x6F) and the write identifier (0x00). The second byte is left empty, because we want to read address 0x00. Application Note 14 V1.0,

15 Implementation (and project example) Write operation with 2 bytes: Set the TPSCTRL.TPS field to 0x02, indicating a transmission of two bytes. Add 0xDE (address and write identifier) and 0x00 (in this case omitted) to the FIFO (TXD). Write 0xF to the Interrupt Clear Register (ICR) to clear all interrupts. We wait until the two byte send has ended (line 13). The PIRQSS (Protocol Interrupt Request Source Status) register contains a bit field (TX_END) which is set to one if the sending process has ended. At this point of the transmission the RTC module knows the address we want to read and waits until a read command is sent, to return the requested data. On line 16 the ICR register is cleared again. On line 17 the PIRQSS interrupts are cleared by writing them into the PIRQSC (Protocol Interrupt Request Source Clear) register. We are now ready to send new data over the I2C bus. Now we want to receive exactly eight bytes, because this is the total size of the time and date component in the RTCs memory. Set TPSCTRL.TPS to 0x01 because we send one byte Set MRPSCTRL.MRPS to 0x08 because we want to receive eight bytes. We need to address the RTC in the first byte, but this time we want to read data, therefore we use the read identifier (0x01) and add 0xDF into the TXD FIFO. Clear all interrupts by writing 0x0F into the ICR and wait until the read operation ends. After the transmission the input FIFO is filled with eight bytes. Because the FIFO register is 32 bit wide, four bytes are in the first FIFO entry and the other four bytes are contained in the second FIFO entry (The data extraction is performed on line 29 and 30 of Code Listing 2). The received byte count can be read from the RPSSTAT.RPS field. Use this to verify that the transmission was successful. Finally, the data can be converted into the correct format with the function createdatefromdata(). Application Note 15 V1.0,

16 4.2.3 Convert to Time Structure Using the RTC (Real-Time Clock) on the TC2x5 Application Kit Implementation (and project example) Data has to be converted into a usable structure. All time and date elements are inserted into the TIME structure (Code Listing 3). Values which are provided in the BCD format are converted using the function Bcd2Dec (Code Listing 4). The time and date values are bit-shifted, masked and then converted to decimal format. If the argument time is set to 0x00 the function can also be used to convert alarm byte blocks void createdatefromdata(uint32_t* data, TIME* pacttime, uint8_t time){ } pacttime->flags.b.hour_12 = (*(data+0) >> 22) & 0x1; pacttime->seconds = Bcd2Dec(*(data+0) & 0x7F); pacttime->minutes = Bcd2Dec(*(data+0)>>8 & 0x7F); if(pacttime->flags.b.hour_12 == 0x0){ pacttime->hours = Bcd2Dec(*(data+0)>>16 & 0x3F); pacttime->flags.b.pm_set = 0x0; } else { pacttime->hours = Bcd2Dec(*(data+0)>>16 & 0x1F); pacttime->flags.b.pm_set = (uint8_t)(*(data+0)>>21 & 0x1); } pacttime->day = Bcd2Dec((*(data+0)>>24) & 0x07); pacttime->date = Bcd2Dec((*(data+1)>>0) & 0x3F); pacttime->month = Bcd2Dec((*(data+1)>>8) & 0x1F); if(time){ pacttime->year = Bcd2Dec(*(data+1)>>16 & 0xFF); pacttime->flags.b.alarm0 = *(data+1)>>28 & 0x1; pacttime->flags.b.alarm1 = *(data+1)>>29 & 0x1; } pacttime->flags.b.leap_year = *(data+1)>>13 & 0x1; pacttime->flags.b.running = *(data+0)>>7 & 0x1; Code Listing 3 Convert Data to Date / Time static inline uint8_t Bcd2Dec(uint8_t bcd) { return ((bcd >> 4)*10+(bcd & 0x0F)); } static inline uint8_t Dec2Bcd(uint8_t dec) { return (((dec/10)<<4)+(dec%10)); } Code Listing 4 BCD to Dec and Dec to BCD Application Note 16 V1.0,

17 4.3 Using the analog clock example project Using the RTC (Real-Time Clock) on the TC2x5 Application Kit Implementation (and project example) If the project as described in this chapter was successfully built and the programmed onto the TC2x5 Application Kit, you will have a simple analog clock. To get the correct time you need to set the time at the first startup only, to your local time. Note: Please do not forget to insert the battery, otherwise you will have to set the time again if you unplug the board. If you have an active timer defined, you are able to wake the board up from standby at the defined time. To test this, unplug your board and plug it back in, but do not press the start button. If the alarm goes off the board will start automatically. Active alarms are displayed on the top of the display. Note: Installation and basic setup instructions can be found in the README.TXT and INSTALL.TXT in the root directory of the projects package. Figure 5 Analog clock example Application Note 17 V1.0,

18 w w w. i n f i n e o n. c o m Published by Infineon Technologies AG