AP16058 C161RI 0003H 1001B 0011B 0111B 0AE80F09 E6E80300 1AE8297F 0AE80F00 - Datasheet Archive

 

AP16058 SAB C161RI BB I m p lem en ta t io n o f the powe r m an age men t f ea tu r es w i th th e K e i l c o m p i le r . Micr

 

Application Note, V 1.0, Feb.2004 AP16058 AP16058 SAB C161RI C161RI BB I m p lem en ta t io n o f the powe r m an age men t f ea tu r es w i th th e K e i l c o m p i le r . Micr ocon tro l lers N e v e r s t o p t h i n k i n g . SAB C161RI C161RI BB Revision History: 2004-02 V 1.0 Previous Version: Page Subjects (major changes since last revision) All Updated Layout to Infineon Corporate Design, updated release to 1.0, Content unchanged! Controller Area Network (CAN): License of Robert Bosch GmbH We Listen to Your Comments Any information within this document that you feel is wrong, unclear or missing at all? Your feedback will help us to continuously improve the quality of this document. Please send your proposal (including a reference to this document) to: mcdocu.comments@infineon.com Edition 2004-02 Published by Infineon Technologies AG 81726 München, Germany © Infineon Technologies AG 2006. 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 your nearest Infineon Technologies Office (www.infineon.com). Warnings Due to technical requirements components may contain dangerous substances. For information on the types in question please contact your nearest Infineon Technologies Office. Infineon Technologies Components may only be used in life-support devices or systems 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. AP16058 AP16058 Implementation of the power management features Table of Contents Table of Contents Page 1 Introduction . 2 2 Implementation. 2 3 Appendix . 2 Application Note 3 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Introduction 1 Introduction The microcontrollers of the Infineon 16-bit family have been designed to meet the high performance requirements of real-time embedded control applications. The architecture of this family has been optimized for high instruction throughput and minimum response time to external interrupts. The core of the 16-bit family has been developed with a modular family concept in mind. All family members execute an efficient control-optimized instruction set. This allows an easy and quick implementation of new family members with different internal memory sizes and technologies, different sets of on-chip peripherals and/or different numbers of IO pins. The C161RI C161RI device is further enhanced by a flexible power management. This power management mechanism provides effective means to control the power that is consumed in a certain state of the controller and thus allows the minimization of the overall power consumption with respect to a given application. To implement these features it can be made use of both assembler programming and high level language programming (Keil C). In this application note the main focus lays on a pure C-language solution. For the assembler solution only hints are given. Application Note 4 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Implementation 2 Implementation To make use of the power management at the C161RI C161RI it is important to know how we use the unlock sequence. The correct execution of this unlock sequence is very important for that feature. To program the power management the registers SYSCON2 and SYSCON3 have to be used. The power management control registers SYSCON2 and SYSCON3 control functions and modes which are critical for the C161RI C161RI's operation. For this reason they are locked (except for bitfield SYSRLS in register SYSCON2) after the execution of EINIT (like register SYSCON) so these vital system functions cannot be changed inadvertently e.g. by software errors. However, as these registers control the power management they need to be accessed during operation to select the appropriate mode. The system control software gets this access via a special unlock sequence which allows one single write access to either SYSCON2 or SYSCON3 when executed properly. This provides a maximum of security. Note: Of course SYSCON2 and SYSCON3 may be read at any time without restrictions. The unlock sequence is executed by writing defined values to bitfield SYSRLS using defined instructions (see table below). The instructions of the unlock sequence (including the intended write access) must be secured with an EXTR instruction (switch to ESFR space and lock interrupts). Note: The unlock sequence provides no write access to register SYSCON. The basic routine to unlock the power management consists of the following assembler instructions: EXTR BFLDL MOV BSET #xH SYSCON2,#0FH,#09H SYSCON2,#0003H 0003H SYSCON2.2 ;Switch ;Unlock ;Unlock ;Unlock to ESFR space and unlock sequence sequence, step 1 (1001B 1001B) sequence, step 2 (0011B 0011B) sequence, step 3 (0111B 0111B) The x in the EXTR instruction indicates the number of those instructions which should be accessed in the ESFR range. Application Note 5 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Implementation A typical error in executing the unlock sequence occurs if the wrong hardware address is put into the header file, where SYSCON2 is declared. For the C161RI C161RI BB step it must be the hardware address F1D0h. (The correct instruction is usually in the header file called reg161RI.h. Syntax: sfr SYSCON2 = 0xF1D0;) This address is located in the ESFR range. Therefore it has to be taken care that the access to this register is correct. Accesses to this address are usually performed by the short address and this short address appears both in the SFR area and in the ESFR area. The C161 will realize the right area by means of the EXTR instruction. In addition it has to be taken care about the right bit address of the SYSCON2.2 bit. In our case we have declared a name for this bit called UNLOCK. Like the SYSCON2 address it has to be defined in the header file reg161RI.reg. (Syntax: bit UNLOCK = SYSCON2^2; Attention: the syntax of the Tasking compiler could be different here.) For advanced power management the register SYSCON3 has to be used. A similar code to SYSCON2 has to be implemented in the header file reg161RI.h - again the hardware address has to be checked. (Syntax: sfr SYSCON3 = 0xF1D4;) To add the unlock sequence to the source code it is now made use of intrinsic functions. These functions are delivered together with the Keil compiler. The declaration of these functions can be found in the header file intrins.h. This file has to be included in the source code. The intrinsic functions help the C-language programmer to use C161RI-specific assembler instructions. To execute the unlock sequence in the right way it is proposed to use the functions _bfld_() and _nop_(). After the unlock sequence the "power management instruction" will be executed. In our example the CPU has to be slowed down. The code has to be implemented in the following way: _bfld_(SYSCON2,0x000F,0x0009); SYSCON2 = 0x03; UNLOCK = 1; _bfld_(SYSCON2, 0x7F00, 0x2900); /* execute unlock sequence */ /* slow down the CPU */ Note: The command SYSCON2 = 0x03; writes only to the bits SYSRLS in the register SYSCON2. (Register SYSCON2 is not unlocked yet.) Note: In the intrinsic function _bfld_() only constant values may be used. A look at the generated assembler code (use compiler option CD) in the list file shows the following result: Application Note 6 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Implementation Hex code D1B0 0AE80F09 0AE80F09 E6E80300 E6E80300 2FE8 1AE8297F 1AE8297F Assembler instruction EXTR #04H BFLDL SYSCON2,#0FH,#09H MOV SYSCON2,#03H BSET UNLOCK BFLDH SYSCON2,#07FH,#029H ;execute unlock sequence ;slow down CPU executed Note: The command EXTR is added automatically by the compiler. It calculates the correct number of instructions which use ESFR registers. An advanced technique to avoid problems with the unlock sequence is to initialize the bitfield SYSRLS with 0, before executing the unlock sequence. It is strongly recommended to add the following instructions: bfld_(SYSCON2,0x000F,0x0000); /* initialize bitfield SYSRLS */ _nop_(); It is very important to add one _nop_() instruction after that initialization. If it is missed the compiler will be confused and generate the following result (together with unlock sequence and the instruction for slow down the CPU): D1B0 0AE80F00 0AE80F00 0AE80F09 0AE80F09 E6E80300 E6E80300 2FE8 D180 1AE8297F 1AE8297F EXTR BFLDL BFLDL MOV BSET EXTR BFLDH #04H SYSCON2,#0FH,#00H SYSCON2,#0FH,#09H SYSCON2,#03H UNLOCK #01H SYSCON2,#07FH,#029H ;initialize bitfield SYSRLS ;execute unlock sequence ;!!! error !!! ;slow down CPU not executed This sequence will cause an error which is not obvious at once. The included instruction EXTR #01H interrupts the correct execution of the unlock sequence. So, adding one _nop_() instruction at the right place in the C-source code solves this problem. The right code is listed below: bfld_(SYSCON2,0x000F,0x0000); _nop_(); _bfld_(SYSCON2,0x000F,0x0009); SYSCON2 = 0x03; UNLOCK = 1; _bfld_(SYSCON2, 0x7F00, 0x2900); Application Note /* initialize bitfield SYSRLS */ /* Do not miss the NOP! */ /* execute unlock sequence */ /* slow down the CPU */ 7 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Implementation This C-code will be compiled to: D180 0AE80F00 0AE80F00 CC00 D1B0 0AE80F09 0AE80F09 E6E80300 E6E80300 2FE8 1AE8297F 1AE8297F EXTR BFLDL NOP EXTR BFLDL MOV BSET BFLDH #01H SYSCON2,#0FH,#00H ;initialize bitfield SYSRLS #04H SYSCON2,#0FH,#09H SYSCON2,#03H UNLOCK SYSCON2,#07FH,#029H ;execute correct unlock sequence ;slow down CPU will be executed After executing an instruction dealing with SYSCON2 and SYSCON3 an additional check of the right content of SYSCON2 and SYSCON3 is recommended (See enclosed source code list file), e.g. if (SYSCON2 & 0x7F00) != 0x0100) return 0; The function will return with an error indication if the unlocksequence plus power management instruction have failed. An alternative to implement the necessary code in high level language is to use in-line assembler. The problem is that the Keil compiler is not very convenient with large projects using in-line assembler. To add in-line assembler in a source file the compiler option ASM/ENDASM has to be used. #pragma asm ;in-line assembler instructions #pragma endasm Together with ASM/ENDASM always the option SRC has to be used (see Keil Compiler User´s guide). This option forces the C-compiler to generate only assembler code out of the C source code. This code has to be translated by the assembler separately. Application Note 8 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix 3 Appendix /*/ /* File : pdwn16.C */ /* Date : 31.07.1998 */ /* Version : V4.3 */ /* */ /* Copyright (c) 1988-1998, Infineon Technologies AG. */ /* All rights reserved. */ /* */ /* Purpose : Driver functions for the power management */ /* for 16 Bit microcontroller C161RI C161RI. */ /* Hint: take care of the stepping code of C161RI C161RI. */ /* Use only BB steps. */ /*/ /* = */ /* Includes */ /* = */ #include "reg161.h" #include /* = */ /* Local Macros & Definitions */ /* = */ #define unlocksequence; ); SYSCON2=0x03;UNLOCK=1 /* = */ /* Global function definition */ /* = */ Application Note 9 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* Function: SDD16 SDD16_on() */ /* Parms : unsigned char speed: factor for the slow down divider */ /* in this function must be 0, 1, 2, 3, 4, 5, 10, 31. The */ /* speed will be reduced according to the follwing rule: */ /* e.g. 2: from 2+1 = 3 clock cycles 2 will be dropped => */ /* clock/3 (0: 0+1 = 1 clock cycles 0 will be dropped => */ /* clock/1. So, the range will be clock/1 . clock/32 */ /* Attention: always check the code generated by the */ /* compiler!!! */ /* Purpose : Slow down the C161 RI. Attention: CPU, Peripherals and */ /* Interfaces will slow down. So, change the time base for */ /* timers and for interefaces. */ /* Returns 1, if the action was successful. Else 0. */ /*/ unsigned char SDD16 SDD16_on(unsigned char speed) { if (speed = 0) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*0); if (SYSCON2 & 0x7F00) != 0x0100) return 0; return 1; }; if (speed = 1) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*1); if (SYSCON2 & 0x7F00) != 0x0500) return 0; return 1; }; Application Note 10 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix if (speed = 2) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*2); if (SYSCON2 & 0x7F00) != 0x0900) return 0; return 1; }; if (speed = 3) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*3); if (SYSCON2 & 0x7F00) != 0x0D00) return 0; return 1; }; if (speed = 4) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*4); if (SYSCON2 & 0x7F00) != 0x1100) return 0; return 1; }; if (speed = 5) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*5); if (SYSCON2 & 0x7F00) != 0x1500) return 0; return 1; }; Application Note 11 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix if (speed = 10) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*10); if (SYSCON2 & 0x7F00) != 0x2900) return 0; return 1; }; if (speed = 31) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0100+(0x0400*31); if (SYSCON2 & 0x7F00) != 0x7D00) return 0; return 1; }; return 0; } /*/ /* Function: SDD16 SDD16_off() */ /* Parms : none */ /* Purpose : Switch off the slow down divider of the C161 RI. */ /* Attention: CPU, Peripherals and Interfaces will change */ /* their speed. So, change the time base for */ /* timers and for interefaces. */ /* Attention: always check the code generated by the */ /* compiler!!! */ /* Returns 1, if the action was successful. Else 0. */ /*/ unsigned char SDD16 SDD16_off(void) { unlocksequence; /* now SYSCON2.0 . SYSCON2.14 is ready to be written */ _bfld_(SYSCON2, 0x7F00, 0x0000); if (SYSCON2 & 0x7F00) != 0x0000) return 0; return 1; } Application Note 12 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* Function: ADC16 ADC16_off() */ /* Parms : none */ /* Purpose : Switch off the ADC of the C161 RI to save system power */ /* (power management). The complete ADC can be started */ /* again, if the ADC16 ADC16_on() function is executed. (This */ /* means, that an external device which wants to send an */ /* signal to be AD-converted has firstly to call by an */ /* interrupt. The interrupt service has to call that */ /* ADC16 ADC16_on() function. Be aware of time critical analog */ /* signals!) Returns 1, if the action was successful. Else */ /* 0. */ /*/ unsigned char ADC16 ADC16_off(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0001, 0x0001); if (SYSCON3 & 0x0001) != 0x0001) return 0; return 1; } /*/ /* Function: ADC16 ADC16_on() */ /* Parms : none */ /* Purpose : Switch on the ADC of the C161 RI (power management). */ /* (see ADC16 ADC16_off). Returns 1, if the action was */ /* successful. Else 0. */ /*/ unsigned char ADC16 ADC16_on(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0001, 0x0000); if (SYSCON3 & 0x0001) != 0x0000) return 0; return 1; } Application Note 13 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* Function: ASC016 ASC016_off() */ /* Parms : none */ /* Purpose : Switch off the ASC0 of the C161 RI to save system power */ /* (power management). The complete ASC0 can be started */ /* again, if the ASC016 ASC016_on() function is executed. (This */ /* means, that an incoming byte may only be received, if */ /* the ASC0 is switched on fast enough by an interrupt */ /* handler.) Returns 1, if the action was successful. Else */ /* 0. */ /*/ unsigned char ASC016 ASC016_off(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0002, 0x0002); if (SYSCON3 & 0x0002) != 0x0002) return 0; return 1; } /*/ /* Function: ASC016 ASC016_on() */ /* Parms : none */ /* Purpose : Switch on the ASC0 of the C161 RI (power management). */ /* (see ASC016 ASC016_off) Returns 1, if the action was */ /* successful. Else 0. */ /*/ unsigned char ASC016 ASC016_on(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0002, 0x0000); if (SYSCON3 & 0x0002) != 0x0000) return 0; return 1; } Application Note 14 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* Function: SSC16 SSC16_off() */ /* Parms : none */ /* Purpose : Switch off the SSC of the C161 RI to save system power */ /* (power management). The complete SSC can be started */ /* again, if the SSC16 SSC16_on() function is executed. (This */ /* means, that an incoming byte may only be received, if */ /* the SSC0 is switched on fast enough by an interrupt */ /* handler.) Returns 1, if the action was successful. Else */ /* 0. */ /*/ unsigned char SSC16 SSC16_off(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0004, 0x0004); if (SYSCON3 & 0x0004) != 0x0004) return 0; return 1; } /*/ /* Function: SSC16 SSC16_on() */ /* Parms : none */ /* Purpose : Switch on the SSC of the C161 RI (power management). */ /* (see SSC16 SSC16_off) Returns 1, if the action was */ /* successful.Else 0. */ /*/ unsigned char SSC16 SSC16_on(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0004, 0x0000); if (SYSCON3 & 0x0004) != 0x0000) return 0; return 1; } Application Note 15 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* Function: GPT16 GPT16_off() */ /* Parms : none */ /* Purpose : Switch off the GPT (Timer Unit) of the C161 RI to save */ /* system power (power management) Returns 1, if the */ /* action was successful. Else 0. */ /*/ unsigned char GPT16 GPT16_off(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0008, 0x0008); if (SYSCON3 & 0x0008) != 0x0008) return 0; return 1; } /*/ /* Function: GPT16 GPT16_on() */ /* Parms : none */ /* Purpose : Switch on the GPT (Timer Unit) of the C161 RI (power */ /* management). (see GPT16 GPT16_off) Returns 1, if the action */ /* was successful. Else 0. */ /*/ unsigned char GPT16 GPT16_on(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0008, 0x0000); if (SYSCON3 & 0x0008) != 0x0000) return 0; return 1; } Application Note 16 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* Function: I2C16 I2C16_off() */ /* Parms : none */ /* Purpose : Switch off the I2C of the C161 RI to save system power */ /* (power management). The complete I2C can be started */ /* again, if the I2C16 I2C16_on() function is executed. (This */ /* means, that an incoming byte may only be received, if */ /* the I2C is switched on fast enough by an interrupt */ /* handler.) Returns 1, if the action was successful. Else */ /* 0. */ /*/ unsigned char I2C16 I2C16_off(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0800, 0x0800); if (SYSCON3 & 0x0800) != 0x0800) return 0; return 1; } /*/ /* Function: I2C16 I2C16_on() */ /* Parms : none */ /* Purpose : Switch on the I2C of the C161 RI (power management). */ /* (see I2C16 I2C16_off) Returns 1, if the action was */ /* successful. Else 0. */ /*/ unsigned char I2C16 I2C16_on(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x0800, 0x0000); if (SYSCON3 & 0x0008) != 0x0000) return 0; return 1; } Application Note 17 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* Function: PCD16 PCD16_off() */ /* Parms : none */ /* Purpose : Switch off the PCD (Peripheral Clock) of the C161 RI to */ /* save system power (power management). Returns 1, if the */ /* action was successful. Else 0. */ /*/ unsigned char PCD16 PCD16_off(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x8000, 0x8000); if (SYSCON3 & 0x8000) != 0x8000) return 0; return 1; } /*/ /* Function: PCD16 PCD16_on() */ /* Parms : none */ /* Purpose : Switch on the PCD (Peripheral Clock) of the C161 RI */ /* (power management). (see PCD16 PCD16_off) Returns 1, if the */ /* action was successful. Else 0. */ /*/ unsigned char PCD16 PCD16_on(void) { unlocksequence; /* now SYSCON3.0 . SYSCON3.15 is ready to be written */ _bfld_(SYSCON3, 0x8000, 0x8000); if (SYSCON3 & 0x8000) != 0x8000) return 0; return 1; } Application Note 18 V 1.0, 2004-02 AP16058 AP16058 Implementation of the power management features Appendix /*/ /* File : PDWN16 PDWN16.H */ /* Date : 31.07.1998 */ /* Version : V4.3 */ /* */ /* Copyright (c) 1988-1998, Infineon Technologies AG. */ /* All rights reserved. */ /* */ /* Purpose : Headerfile for PDWN16 PDWN16.C */ /*/ /* = */ /* Extern function declaration */ /* = */ #ifndef _H_POWER #define _H_POWER #include "reg161RI.h" extern extern extern extern extern extern extern extern extern extern extern extern extern extern #endif unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned unsigned Application Note char char char char char char char char char char char char char char SDD16 SDD16_on(unsigned char speed); SDD16 SDD16_off(void); ADC16 ADC16_off(void); ADC16 ADC16_on(void); ASC016 ASC016_off(void); ASC016 ASC016_on(void); SSC16 SSC16_off(void); SSC16 SSC16_on(void); GPT16 GPT16_off(void); GPT16 GPT16_on(void); I2C16 I2C16_off(void); I2C16 I2C16_on(void); PCD16 PCD16_off(void); PCD16 PCD16_on(void); 19 V 1.0, 2004-02 http://www.infineon.com Published by Infineon Technologies AG