搜档网
当前位置:搜档网 › IAR的CSTACK和RSTACK的设置

IAR的CSTACK和RSTACK的设置

RSTACK 程序返回用的,保存的是程序调用函数的返回地址 , 你填写的数值 X 2才是占用的字节数,例如,你填写10,那么RSTACK尺寸是20字节,可以函数嵌套10层左右

CSTACK 函数局部变量用的区域,所有的功能函数使用的局部变量都是从这个堆栈申请使用的,用完了再还回去。子函数里面用到的局部变量都是在这里面取来用的.
例如:
void Fn(void)
{
unsigned char TT[64];
}

TT[64] 就会从CSTACK取出来用,用完后TT没用了,就可以还给CSTACK了,当子函数使用局部变量太多的时候,要注意CSTACK尺寸


当出现CSTACK和RSTACK溢出的时候,一般有2种情况:

1. CSTACK和RSTACK真的不够用

2. 中断反复重入,例如:当进去一个中断,你直接开启总中断,如果这个中断信号还在,那么中断函数会重入,这样你不管设置CSTACK和RSTACK多大,溢出是必然的, 一般情况是,如果你系统想执行所为的中断嵌套,你进去中断后,首先要关闭自身中断,然后再开总中断,退出时再重新开启自身中断


CSTACK设大点,200也不算大。

RSTACK一般设置到32就够了。
32层函数,中断嵌套,一般应该够了。

如果代码空间不是很紧张,最高优化建议用speed优化。



这个问题也困扰过我,现在整理了拿出来。。。。

在中断的时候,RAM溢出了,一般在中断里,堆栈最深,中断里出问题一般是RSTACK 的问题,这个是存函数调用返回地址的,也就是说,函数嵌套调用太多了。而C编译器编译的代码操作堆栈的次数远比我们想的多,当然这也是一个优秀C编译器的高级之处。

我一般碰到的问题是CSTACK设置问题,CSTACK是用来存数据的,这些数据主要用于函数间传递参数、全局变量同步等等。这个你要看E文版的IAR说明书。

这两个参数具体要设置多少,要看MAP文件。IAR不会自动告诉你的,而是需要由用户设定好。

我把我的一个程序改了,在中断里出现下面的提示:

Wed Apr 08 12:53:08 2009: The stack 'CStack' is filled to 100% (16 bytes used out of 16). The warning threshold is set to 90%.

说明我的0X10小了,实际用到的大于16了,而到底这个大于16的数是多少,要看MAP文件里的相关数据。

在你工程目录的Debug\List下,找到你的MAP文件,里面记载着编译器编译你的工程时,资源的使用情况。

打开.MAP文件,搜索 CALL GRAPH ,你会发现你写的每个的函数都在这里,而每个函数用了多少资源,也都列在此。

找到最大的数,设置一下,试试吧。





没遇见过,一般来说函数嵌套调用的层数不会太多,RSTACK我一般设为32都够用了,CSTACK看单片机RAM大小,除了全局变量占用的之外我都全部分配给CSTACK,

也就是说CSTACK = RAM大小 - 全局变量总数 - RSTACK






AVR的堆栈分为2种,一种是硬件堆栈,另一种是软件堆栈。
硬件堆栈存放调用函数的返回地址,其大小跟函数的调用层数相关。如果打开C/C++编译选项中优化选项的交叉调用的值为“unlimited”时,要特别小心。一般设为32应该没什么。其类型为RStack,界面设置值为调用深度,字节数是其2倍。
软件堆栈存放所以局部变量(部分局部变量可能是寄存器变量),如果函数的局部变量中有数组,则其大小要设置大一些。如果不想出错,就跟上楼所说的一样。
硬件堆栈和软件堆栈都是向下增长的(编译器默认),至于是硬件堆栈在低地址,还是软件堆栈在低地址,默认情况下由编译器决定,其地址应该在RAM的相对低的地址,但也可以通过.xcl配置文件进行更改。如:
-D_..X_RSTACK_SIZE=16 // 硬件堆栈的大小
-D_..X_CSTACK_SIZE=20 // 软件堆栈的大小

-Z(DATA)RSTACK+_..X_RSTACK_SIZE=(_..X_SRAM_END-_..X_RSTACK_SIZE)-_..X_SRAM_END
-Z(DATA)CSTACK+_..X_CSTACK_SIZE=(_..X_SRAM_END-_..X_RSTACK_SIZE-_..X_CSTACK_SIZE)-(_..X_SRAM_END-_..X_RSTACK_SIZE)

上述例子就硬性确定了硬件堆栈和软件堆栈的大小与位置。
另:以-D定义的数值,其变量名是可以自己定的。




在编译开关里面加入--string_literals_in_flash就可以把 (C/C++ Compile-->Extra Options-->Use command line options-->--string_literals_in_flash
fun("str") 的"str"放到FLASH里。
--string_literals_in_flash
如果直接定义const unsigned char str的话在flash里面,但初始化拷贝到RAM中,如果定义__flash const unsigned char str的话就不会拷贝到RAM中了
------------------------------------------------------------------------------------------------------------------------
需要设置General options -> Library Option -> printf formatter设置成Medium或full
然后需要设置CSTACK大小,General options -> System 默认的是0x80,更改为0x100或者更大



CTRL + T格式化代码
CTRL+B Match Brackets
CTRL+T Auto Indent
CTRL+K Block Comment
CTRL+SHIFT+K Block Uncomment



编译器清零只是把 .bss段(GCC),NEAR_Z(IAR,或者TINY_Z,FAR_Z)清零。
其他段并没有清零



1、__no_init对RAM里的变量修饰结果为:启动代码内不会操作这个变量。
2、__no_init对EEP里的变量修饰结果为:生成EEP文件的时候不向文件内对应地址写0,和启动代码无关。




CONST定义的变量会放在FLASH和ram中。
使用下面这个加FLASH,就可以编译过去。

/*
********************************************************************************************
头部文件名: MCU_C_Macro_Data_Define.h
头部文件名称: 嵌入式微处理器

C程序的数据类型和常用指令宏定义的头部文件
适用器件芯片类型: 嵌入式微处理器
文件版本: 1.0
文件功能:
本文件是对嵌入式微处理器C程序的数据类型、在编程中一些常用操作和指令及位操作进行
宏定义的头部文件。
文件说明:
在使用本文件前,必须首先使用全局预定义字符来对C编译系统进行定义!
对各种C编译系统规定使用的全局预定义字符如下(中括号里面的字符):
①.IAR Embedded Workbench for Atmel AVR ------ [_IAR_EW_AVR_]
②.ICCAVR ------------------------------------ [_ICC_AVR_]
③.CodeVision AVR ---------------------------- [_CodeVision_AVR_]
编译工具软件:
链接文件:

编作者:
编作者 E-Mail: PTZSW@https://www.sodocs.net/doc/181156811.html,
编制日期: 2005年8月18日
----------------------------------------------------------------------------------------
头部文件版本历史:
2005年8月18日 -------- 版本 1.0 :发行版本
********************************************************************************************
*/

/*==========================================================================================
下面两条指令是本头部文件条件编译的预处理指令,用于防止本头部文件被其他文件重复引用。
==========================================================================================*/
#ifndef MCU_C_MACRO_DATA_DEFINE_H // "MCU_C_MACRO_DATA_DEFINE_H" 条件编译开始
#define MCU_C_MACRO_DATA_DEFINE_H

/*==========================================================================================
下面这三条指令是用于区分编译系统为 C++ 或 C 的预处理指令。
"__cplusplus" 为 C++ 预处理器名字,这三条指令表明接在其下面的那些指令为 C 程序特征。
==========================================================================================*/
#ifdef __cplusplus
extern "C" {
#endif



/*==========================================================================================
定义系统处理的数据位字长度大小:
==========================================================================================*/
#define SYSDATA_BITNUM 8 // 定义系统数据位的字长数


/*==========================================================================================
为了做到较好的软件可移植性,推荐用户在编程时使用下面定义的数据类型大小
==========================================================================================*/
typedef unsigned char BOOLEAN; // 定义【布尔(逻辑)】数据类型

typedef char char8; // char8 代表【有符号字符】数据类型
typedef unsigned char Uc

har8; // Uchar8 代表【无符号字符】数据类型
typedef int int16; // int16 代表【有符号整数】数据类型
typedef unsigned int Uint16; // Uint16 代表【无符号整数】数据类型
typedef long int int32; // int32 代表【有符号长整数】数据类型
typedef unsigned long int Uint32; // Uint32 代表【无符号长整数】数据类型
typedef float float32; // float32 代表【单精度浮点数】数据类型

/*==========================================================================================
位操作定义(用于变量中某一位的直接置位/清除位),推荐置位/清除位的语句为:
①.变量名称 |= BITn; 置位操作(将变量与下面的位定义值进行按位或运算)
②.变量名称 &= ~BITn; 清除位操作(将变量与下面的位定义值的非值进行按位与运算)
==========================================================================================*/
#define BIT0 0x01 // BIT0 = (1<<1) = 0b00000001
#define BIT1 0x02 // BIT1 = (1<<2) = 0b00000010
#define BIT2 0x04 // BIT2 = (1<<3) = 0b00000100
#define BIT3 0x08 // BIT3 = (1<<4) = 0b00001000
#define BIT4 0x10 // BIT4 = (1<<5) = 0b00010000
#define BIT5 0x20 // BIT5 = (1<<6) = 0b00100000
#define BIT6 0x40 // BIT6 = (1<<7) = 0b01000000
#define BIT7 0x80 // BIT7 = (1<<8) = 0b10000000

#define BIT_HIGH BIT7 // BIT7 = (1<<8) = 0b10000000
#define BIT_LOW BIT0 // BIT0 = (1<<1) = 0b00000001



/*
********************************************************************************************
AVR单片机常用操作和指令宏的定义
********************************************************************************************
*/
/*--------------------------------------------------------------------------------------
位操作指令的宏定义:
①.对存储在地址中的数据变量执行置位操作指令: SET_BIT(ADDRESS,BIT)
②.对存储在地址中的数据变量执行清位操作指令: CLEAR_BIT(ADDRESS,BIT)
③.测试存储在地址中的数据变量某一位数值的指令:TEST_BIT(ADDRESS,BIT)
其中:ADDRESS ----- 变量存储地址
BIT --------- 位数(阿拉伯数字)
--------------------------------------------------------------------------------------*/
#if defined(_IAR_EW_AVR_) || defined(_ICC_AVR_) || defined(_CodeVision_AVR_)
#define SET_BIT(ADDRESS,BIT) ((ADDRESS) |= (1<<(BIT)))
#define CLEAR_BIT(ADDRESS,BIT) ((ADDRESS) &= ~(1<<(BIT))

)
#define TEST_BIT(ADDRESS,BIT) ((ADDRESS) & (1<<(BIT)))
#endif

/*--------------------------------------------------------------------------------------
IAR Embedded Workbench for AVR 编译器对16位的寄存器进行读写操作指令的宏定义:
①.对16位的寄存器进行写入的操作指令:OUT_WORD(ADDRESS,VAL)
②.读取16位的寄存器中内容的操作指令:IN_WORD(ADDRESS,VAL)
其中:ADDRESS ----- 寄存器的存储地址
VAL --------- 位数(阿拉伯数字)
--------------------------------------------------------------------------------------*/
#if defined(_IAR_EW_AVR_) // "IAR Embedded Workbench AVR " 条件编译开始
#define OUT_WORD(ADDRESS,VAL) \
{\
__disable_interrupt();\
(ADDRESS) = (VAL);\
__enable_interrupt();\
}

#define IN_WORD(ADDRESS,VAL) \
{\
__disable_interrupt();\
(VAL) = (ADDRESS);\
__enable_interrupt();\
}
#endif // "defined(_IAR_EW_AVR_)" 条件编译结束



/*--------------------------------------------------------------------------------------
在编程中一些常用操作和指令宏的定义:
①.WDR() -------- 看门狗定时器复位指令
②.SEI() -------- 使能全局中断指令
③.CLI() -------- 禁止全局中断指令
④.SLEEP() ------ MCU进入休眠状态指令
⑤.NOP() -------- 空操作指令
--------------------------------------------------------------------------------------*/
#if defined(_IAR_EW_AVR_) || defined(_ICC_AVR_) || defined(_CodeVision_AVR_)
#define WDR() asm("wdr") // 看门狗定时器复位
#define SEI() asm("sei") // 使能全局中断
#define CLI() asm("cli") // 禁止全局中断
#define SLEEP() asm("sleep") // MCU进入休眠状态
#define NOP() asm("nop") // 空操作
#endif



/*--------------------------------------------------------------------------------------
EEPROM存储器扩展的操作和指令宏的定义:
①.eeprom ----------------------------- 指向 EEPROM 存储器的关键字
②.EEPROM_WRITE(ADDRESS, DATA) -------- 写入数据到 EEPROM 存储器中某一个具体地址的指令
③.EEPROM_READ(DATA, ADDRESS) --------- 从 EEPROM 存储器中某一个具体地址读取数据的指令
其中:ADDRESS --------- 访问 EEPROM 存储器的具体地址
DATA ------------ 对 EEPROM 存储器执行操作的数据
--------------------------------------------------------------------------------------*/
#if defined(_IAR_EW_AVR_) // "IAR Embedded Workbench AVR " 条件编译开始
#define eeprom __eeprom // 定义指向 EEPROM 存储器的关键字

#ifndef EEPROM_WRITE
#define EEPROM_WRITE(ADDRESS, DATA) __EEPUT(ADDRESS, DATA)
#end

if

#ifndef EEPROM_READ
#define EEPROM_READ(DATA, ADDRESS) __EEGET(DATA, ADDRESS)
#endif

#ifndef _EEPUT
#define _EEPUT(V,A) __EEPUT(V,A)
#endif

#ifndef _EEGET
#define _EEGET(V,A) __EEGET(V,A)
#endif

#ifdef __HAS_EEPROM__ // "__HAS_EEPROM__"条件编译开始
#define __EEPUT(ADDRESS, DATA) (*((unsigned char __eeprom *)ADDRESS) = DATA)
#define __EEGET(DATA, ADDRESS) (DATA = *((unsigned char __eeprom *)ADDRESS))
#else
#define __EEPUT(ADDRESS, DATA) { \
while (EECR & 0x02); \
EEAR = (ADDRESS); \
EEDR = (DATA); \
EECR = 0x04; \
EECR = 0x02; \
}

#define __EEGET(DATA, ADDRESS) { \
while (EECR & 0x02); \
EEAR = (ADDRESS); \
EECR = 0x01; \
(DATA) = EEDR; \
}
#endif // "__HAS_EEPROM__" 条件编译结束
#endif // "defined(_IAR_EW_AVR_)" 条件编译结束


#if defined(_CodeVision_AVR_) // "CodeVision AVR 编译器"条件编译开始
#define EEPROM_WRITE(ADDRESS, DATA) (eeprom *((volatile unsigned char *)ADDRESS) = DATA)
#define EEPROM_READ(DATA, ADDRESS) (DATA = eeprom *((volatile unsigned char *)ADDRESS))
#endif // "_CodeVision_AVR_" 条件编译结束


#if defined(_ICC_AVR_) // "ICC AVR 编译器"条件编译开始

#endif // "_ICC_AVR_" 条件编译结束


/*
********************************************************************************************
AVR单片机各编译系统的字符不同而操作功能相同的扩展关键字,为彼此之间相至兼容而定义的宏字符
********************************************************************************************
*/
/*==========================================================================================
IAR Embedded Workbench for AVR 头部文件“comp_a90.h”中的兼容性宏定义
==========================================================================================*/
#if defined(_IAR_EW_AVR_) // "IAR Embedded Workbench AVR " 条件编译开始

#ifndef __COMP_A90_H // "__COMP_A90_H" 条件编译开始
#define __COMP_A90_H

#define tiny __tiny
#define near __near
#define far __far
#d

efine huge __huge

#define flash const __flash
#define farflash const __farflash

#define nearfunc __nearfunc
#define farfunc __farfunc

#define sfrb int int int Cannot use sfrb keyword in iccAVR;
#define sfrw int int int Cannot use sfrw keyword in iccAVR;

#define monitor __monitor
#define C_task __C_task
#define no_init __no_init

#ifndef _CLI
#define _CLI() __disable_interrupt()
#endif

#ifndef disable_interrupt
#define disable_interrupt() __disable_interrupt()
#endif

#ifndef _SEI
#define _SEI() __enable_interrupt()
#endif

#ifndef enable_interrupt
#define enable_interrupt() __enable_interrupt()
#endif

#ifndef _NOP
#define _NOP() __no_operation()
#endif

#ifndef _SLEEP
#define _SLEEP() __sleep()
#endif

#ifndef _LPM
#define _LPM(ADDR) __load_program_memory(ADDR)
#endif

#ifdef __HAS_ELPM__
#ifndef _ELPM
#define _ELPM(ADDR) __extended_load_program_memory(ADDR)
#endif
#endif

#ifndef _WDR
#define _WDR() __watchdog_reset()
#endif

#ifndef _OPC
#define _OPC(opCode) __insert_opcode(opCode)
#endif

#endif // "__COMP_A90_H" 条件编译结束

#endif // "defined(_IAR_EW_AVR_)" 条件编译结束


/*==========================================================================================
IAR Embedded Workbench for AVR 头部文件“INAVR.H”中的兼容性宏定义
==========================================================================================*/
#if defined(_IAR_EW_AVR_) // "IAR Embedded Workbench AVR " 条件编译开始

#ifndef __INAVR_H // "__INAVR_H" 条件编译开始
#define __INAVR_H

__intrinsic void __no_operation(void);
__intrinsic void __enable_interrupt(void);
__intrinsic void __disable_interrupt(void);
__intrinsic void __sleep(void);
__intrinsic void __watchdog_reset(void);

#define __clear_watchdog_timer() __watchdog_reset()

#pragma language=extended
__intrinsic unsigned char __load_program_memory(const unsigned char __flash *);
#ifdef __HAS_ELPM__
__intrinsic unsigned char __extended_load_program_memory(const unsigned char __farflash *);
#endif
#pragma language=default

__intrinsic void __insert_opcode(unsigned short op);

#if __MEMORY_MODEL__ == 4
#if __CPU__ < 2
#define __STR_MATTR__ __flash
#else
#define __STR_MATTR__ __hugeflash
#endif
#else
#define __STR_MATTR__
#endif


__intrinsic void __require(void *);

__intrinsic void __delay_cycles(unsigned long);

__intrinsic uns

igned char __save_interrupt(void);
#define __get_interrupt_state() __save_interrupt()

__intrinsic void __restore_interrupt(unsigned char);
#define __set_interrupt_state(STATE) __restore_interrupt(STATE)

__intrinsic unsigned char __swap_nibbles(unsigned char);

__intrinsic void __indirect_jump_to(unsigned long);


/*--------------------------------------------------------------------------------------
增强型核心指令集的内在函数定义
--------------------------------------------------------------------------------------*/
#ifdef __HAS_ENHANCED_CORE__

#ifdef __HAS_MUL__
__intrinsic unsigned int __multiply_unsigned(unsigned char, unsigned char);
__intrinsic signed int __multiply_signed(signed char, signed char);
__intrinsic signed int __multiply_signed_with_unsigned(signed char, unsigned char);

__intrinsic unsigned int __fractional_multiply_unsigned(unsigned char, unsigned char);
__intrinsic signed int __fractional_multiply_signed(signed char, signed char);
__intrinsic signed int __fractional_multiply_signed_with_unsigned(signed char, signed char);
#endif

#pragma language=extended

/* SPM */
__intrinsic void __DataToR0ByteToSPMCR_SPM(unsigned char data,
unsigned char byte);
__intrinsic void __AddrToZByteToSPMCR_SPM(void __flash* addr,
unsigned char byte);
__intrinsic void __AddrToZWordToR1R0ByteToSPMCR_SPM(void __flash* addr,
unsigned short word,
unsigned char byte);

#define _SPM_LOCKBITS(Data) __DataToR0ByteToSPMCR_SPM((Data), 0x09)

#define _SPM_ERASE(Addr) __AddrToZByteToSPMCR_SPM((void __flash*)(Addr), 0x03)

#define _SPM_FILLTEMP(Addr,Data) \
__AddrToZWordToR1R0ByteToSPMCR_SPM((void __flash*)(Addr), (Data), 0x01)

#define _SPM_PAGEWRITE(Addr) __AddrToZByteToSPMCR_SPM((void __flash*)(Addr), (0x05))


__intrinsic unsigned char __AddrToZByteToSPMCR_LPM(void __flash* addr,
unsigned char byte);

#define _SPM_GET_LOCKBITS() __AddrToZByteToSPMCR_LPM((void __flash*)0x0001, 0x09)

#define _SPM_GET_FUSEBITS() __AddrToZByteToSPMCR_LPM((void __flash*)0x0000, 0x09)


#ifdef __HAS_ELPM__
__intrinsic void __AddrToZ24ByteToSPMCR_SPM(void __farflash* addr,
unsigned char byte);
__intrinsic void __AddrToZ24WordToR1R0ByteToSPMCR_SPM(void __farflash* addr,
unsigned short word,
unsigned char byte);
#define _SPM_24_ERASE(Addr) __AddrToZ24ByteToSPMCR_SPM((void _

_farflash*)(Addr), 0x03)

#define _SPM_24_FILLTEMP(Addr,Data) \
__AddrToZ24WordToR1R0ByteToSPMCR_SPM((void __farflash*)(Addr), (Data), 0x01)

#define _SPM_24_PAGEWRITE(Addr) __AddrToZ24ByteToSPMCR_SPM((void __farflash*)(Addr), (0x05))

__intrinsic unsigned char __AddrToZ24ByteToSPMCR_ELPM(void __farflash* addr,
unsigned char byte);
#endif
#pragma language=default

#endif //__HAS_ENHANCED_CORE__


/* PORT is a sfrb defined variable */
#define input(PORT) (PORT)
#define output(PORT,VAL) ((PORT)=(VAL))

#define input_block_dec(PORT,ADDRESS,COUNT)\
{ \
unsigned char i;\
unsigned char *addr=(ADDRESS);\
for(i=0;i<(COUNT);i++)\
*addr--=(PORT);\
}

#define input_block_inc(PORT,ADDRESS,COUNT)\
{ \
unsigned char i;\
unsigned char *addr=(ADDRESS);\
for(i=0;i<(COUNT);i++)\
*addr++=(PORT);\
}

#define output_block_dec(PORT,ADDRESS,COUNT)\
{ \
unsigned char i;\
unsigned char *addr=(ADDRESS);\
for(i=0;i<(COUNT);i++)\
(PORT)=*addr--;\
}

#define output_block_inc(PORT,ADDRESS,COUNT)\
{ \
unsigned char i;\
unsigned char *addr=(ADDRESS);\
for(i=0;i<(COUNT);i++)\
(PORT)=*addr++;\
}

/*--------------------------------------------------------------------------------------
一些常用的宏定义
--------------------------------------------------------------------------------------*/
#define __out_word(BaseName, value)\
{\
unsigned char _tH=(value) >> 8;\
unsigned char _tL=(value) & 0xFF;\
BaseName ## H = _tH;\
BaseName ## L = _tL;\
}


#define __out_word_atomic(BaseName, value)\
{\
unsigned char _t=__save_interrupt();\
__disable_interrupt();\
__out_word(BaseName,value);\
__restore_interrupt(_t);\
}

#define __in_word(BaseName, value)\
{\
(value) = (BaseName ## L);\
(value) |= (unsigned short)BaseName ## H << 8;\
}


#define __in_word_atomic(BaseName, value)\
{\
unsigned char _t=__save_interrupt();\
__disable_interrupt();\
__in_word(BaseName, value);\
__restore_interrupt(_t);\
}

#endif // "__INAVR_H" 条件编译结束

#endif // "defined(_IAR_EW_AVR_)" 条件编译结束



/*==========================================================================================
下面这三条指令是用于与上面三条区分编译系统为 C++ 或 C 的预处理指令相对应。用于指定
extern "C" 链接指示符作用域,此处的"}"与上面的"{"相对应,为链接指示符作用结束符。
==========================================================================================*/
#ifdef __cplusplus
}
#endif

#endif // "MCU_C_MACRO_DATA_DEFINE_H" 条件编译结束



/*
*************************************************************

*******************************
本头部文件到此结束
********************************************************************************************
*/










int a; A variable defined in default memory.
int __flash b; A variable in flash memory.
__eeprom int c; A variable in eeprom memory.
int * d; A pointer stored in default memory. The pointer points to an integer in default memory.
int __flash * e; A pointer stored in default memory. The pointer points to an integer in flash memory.
int __flash * __eeprom f; A pointer stored in eeprom memory pointing to an integer stored in flash memory.
int __eeprom * myFunction( int __flash *); A declaration of a function that takes a parameter which is a pointer to an integer stored in flash memory. The function returns a pointer to an integer stored in eeprom memory.


unsigned char __flash * p; 定义一个指向flash的指针,指针本身在sram里面
__eeprom unsigned char* p; 定义一个指向sram的指针,指针本身在eeprom里面

Examples
Please note that the "keywords" mentioned (__near and __far2)
can be any of the IAR memory keywords and that they can be
different for different products; for example, far, huge,
near, tiny, idata, xdata, pdata, and __near.


/* CONST POINTERS */
const int * c1;
int const * c2;
int * const c3; /* Pointer is a constant pointer */
const int const * c4;
const int * const c5; /* Pointer is a constant pointer */
int const * const c6; /* Pointer is a constant pointer */
const int const * const c7; /* Pointer is a constant pointer */

/* POINTS TO NEAR */
__near int __near * n1; /* Pointer is located in NEAR */
int __near * __near n2; /* Pointer is located in NEAR */
__far2 int __near * n3; /* Pointer is located in FAR2 */
int __near * __far2 n4; /* Pointer is located in FAR2 */

/* POINTS TO FAR2 */
__near int __far2 * f1; /* Pointer is located in NEAR */
int __far2 * __near f2; /* Pointer is located in NEAR */
__far2 int __far2 * f3; /* Pointer is located in FAR2 */
int __far2 * __far2 f4; /* Pointer is located in FAR2 */



指针的定义加__generic 试试吧
unsigned char __generic *pt;
uchar __flash ABC[] = { 0x01, 0x02, 0x03 };
uchar TempBuf[8];
这样定义的指针pt,即可指向ABC,也可指向TempBuf.



相关主题